refactor: flatten layout interface structure

Remove DynamicLayoutConfig nesting and move urn, itemPage, metadataBox,
and collectionsBox properties directly under the layout interface to
eliminate unnecessary nesting levels.

Changes:
- Update layout-config.interfaces.ts: Remove DynamicLayoutConfig interface
  and add urn, itemPage, metadataBox, collectionsBox directly to LayoutConfig
- Update default-app-config.ts: Move dynamicLayout properties to top level
- Update environment.test.ts: Move dynamicLayout properties to top level
- Update component property access from layout.dynamicLayout.* to layout.*:
  * dynamic-layout-loader.component.ts
  * dynamic-layout-collection-box.component.ts
  * metadata-container.component.ts
  * resolver-strategy.service.ts
  * identifier.component.ts
- Update config.example.yml: Flatten structure and enhance documentation

Before:
  layout.dynamicLayout.urn
  layout.dynamicLayout.itemPage
  layout.dynamicLayout.metadataBox
  layout.dynamicLayout.collectionsBox

After:
  layout.urn
  layout.itemPage
  layout.metadataBox
  layout.collectionsBox

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: FrancescoMolinaro

config/config.example.yml

@@ -757,6 +757,50 @@ layout:
       - name: checksum
         type: attribute
 
+  # Configuration for URN (Uniform Resource Name) identifier resolution
+  # Maps identifier types (e.g., DOI, Handle, Scopus) to their base URLs for creating resolvable links
+  urn:
+    - name: doi
+      baseUrl: 'https://doi.org/'
+    - name: hdl
+      baseUrl: 'https://hdl.handle.net/'
+    - name: scopus
+      baseUrl: 'https://www.scopus.com/authid/detail.uri?authorId='
+    - name: researcherid
+      baseUrl: 'http://www.researcherid.com/rid/'
+    - name: mailto
+      baseUrl: 'mailto:'
+
+  # Item page layout configuration for different entity types
+  # Defines the visual layout orientation (horizontal/vertical) for various entity types in the item page detail view
+  itemPage:
+    OrgUnit:
+      orientation: vertical
+    Project:
+      orientation: vertical
+    default:
+      orientation: horizontal
+
+  # Metadata box rendering configuration
+  # Defines default CSS column styles for metadata labels and values in item page detail view
+  metadataBox:
+    # CSS classes for metadata label column (default: 'col-3' = 25% width)
+    defaultMetadataLabelColStyle: col-3
+    # CSS classes for metadata value column (default: 'col-9' = 75% width)
+    defaultMetadataValueColStyle: col-9
+
+  # Collections box rendering configuration
+  # Defines default CSS column styles for collections and inline display settings
+  collectionsBox:
+    # CSS classes for collection label column (default: 'col-3 fw-bold' = 25% width, bold text)
+    defaultCollectionsLabelColStyle: col-3 fw-bold
+    # CSS classes for collection value column (default: 'col-9' = 75% width)
+    defaultCollectionsValueColStyle: col-9
+    # CSS classes for collection row styling
+    # defaultCollectionsRowStyle: ''
+    # Whether to display collections inline (true) or in a block layout (false)
+    isInline: true
+
 # Configuration for customization of search results
 searchResults:
   # Metadata fields to be displayed in the search results under the standard ones

src/app/dynamic-layout/dynamic-layout-loader/dynamic-layout-loader.component.ts

@@ -0,0 +1,122 @@
+import {
+  Component,
+  ComponentRef,
+  Inject,
+  Input,
+  OnDestroy,
+  OnInit,
+  ViewChild,
+} from '@angular/core';
+import {
+  APP_CONFIG,
+  AppConfig,
+} from '@dspace/config/app-config.interface';
+import { DynamicLayoutTypeConfig } from '@dspace/config/layout-config.interfaces';
+
+import { DynamicLayoutTab } from '../../core/layout/models/tab.model';
+import { GenericConstructor } from '../../core/shared/generic-constructor';
+import { Item } from '../../core/shared/item.model';
+import { getDynamicLayoutPage } from '../decorators/dynamic-layout-page.decorator';
+import { DynamicLayoutLoaderDirective } from '../directives/dynamic-layout-loader.directive';
+import { LayoutPage } from '../enums/layout-page.enum';
+
+@Component({
+  selector: 'ds-dynamic-layout-loader',
+  templateUrl: './dynamic-layout-loader.component.html',
+  styleUrls: ['./dynamic-layout-loader.component.scss'],
+  imports: [
+    DynamicLayoutLoaderDirective,
+  ],
+})
+export class DynamicLayoutLoaderComponent implements OnInit, OnDestroy {
+
+  /**
+   * DSpace Item to render
+   */
+  @Input() item: Item;
+
+  /**
+   * Tabs to render
+   */
+  @Input() tabs: DynamicLayoutTab[];
+
+  /**
+   * A boolean representing if to show context menu or not
+   */
+  @Input() showContextMenu: boolean;
+
+  /**
+   * Configuration layout form the environment
+   */
+  layoutConfiguration: DynamicLayoutTypeConfig;
+
+
+  @Input() leadingTabs: DynamicLayoutTab[];
+
+  /**
+   * Directive hook used to place the dynamic child component
+   */
+  @ViewChild(DynamicLayoutLoaderDirective, { static: true }) dynamicLayoutLoader: DynamicLayoutLoaderDirective;
+
+  /**
+   * componentRef reference of the component that will be created
+   */
+  componentRef: ComponentRef<Component>;
+
+  constructor(
+    @Inject(APP_CONFIG) protected appConfig: AppConfig,
+  ) {
+  }
+
+  ngOnInit(): void {
+    this.getConfiguration();
+    this.initComponent();
+  }
+
+  /**
+   * Get tabs for the specific item and the configuration for the item
+   */
+  getConfiguration(): void {
+    const itemType = this.item ?.firstMetadataValue('dspace.entity.type');
+    const def = 'default';
+
+    if (!!this.appConfig.layout.itemPage && !!this.appConfig.layout.itemPage[itemType]) {
+      this.layoutConfiguration = this.appConfig.layout.itemPage[itemType];
+    } else {
+      this.layoutConfiguration = this.appConfig.layout.itemPage[def];
+    }
+  }
+
+  /**
+   * Initialize the component depending on the layout configuration
+   */
+  initComponent(): void {
+    const component: GenericConstructor<Component> = this.getComponent();
+    const viewContainerRef = this.dynamicLayoutLoader.viewContainerRef;
+    viewContainerRef.clear();
+
+    this.componentRef = viewContainerRef.createComponent(component);
+    (this.componentRef.instance as any).item = this.item;
+    (this.componentRef.instance as any).tabs = this.tabs;
+    (this.componentRef.instance as any).showContextMenu = this.showContextMenu;
+    (this.componentRef.instance as any).leadingTabs = this.leadingTabs;
+    this.componentRef.changeDetectorRef.detectChanges();
+  }
+
+  /**
+   * Fetch the component depending on the item
+   * @returns {GenericConstructor<Component>}
+   */
+  private getComponent(): GenericConstructor<Component> {
+    return getDynamicLayoutPage(this.layoutConfiguration.orientation as LayoutPage);
+  }
+
+  /**
+   * Destroy componentRef when this component is destroyed
+   */
+  ngOnDestroy(): void {
+    if (this.componentRef) {
+      this.componentRef.destroy();
+    }
+  }
+}

src/app/dynamic-layout/dynamic-layout-matrix/dynamic-layout-box-container/boxes/dynamic-layout-collection-box/dynamic-layout-collection-box.component.ts

@@ -0,0 +1,160 @@
+import {
+  AsyncPipe,
+  NgClass,
+} from '@angular/common';
+import {
+  Component,
+  Inject,
+  OnInit,
+} from '@angular/core';
+import { RouterLink } from '@angular/router';
+import { CollectionDataService } from '@dspace/core/data/collection-data.service';
+import { FindListOptions } from '@dspace/core/data/find-list-options.model';
+import { PaginatedList } from '@dspace/core/data/paginated-list.model';
+import { DynamicLayoutBox } from '@dspace/core/layout/models/box.model';
+import { Collection } from '@dspace/core/shared/collection.model';
+import { Item } from '@dspace/core/shared/item.model';
+import {
+  getFirstCompletedRemoteData,
+  getFirstSucceededRemoteDataPayload,
+  getPaginatedListPayload,
+} from '@dspace/core/shared/operators';
+import { hasValue } from '@dspace/shared/utils/empty.util';
+import {
+  TranslateModule,
+  TranslateService,
+} from '@ngx-translate/core';
+import {
+  BehaviorSubject,
+  combineLatest,
+  Observable,
+  of,
+} from 'rxjs';
+import {
+  map,
+  shareReplay,
+  tap,
+} from 'rxjs/operators';
+
+import { environment } from '../../../../../../environments/environment';
+import { DynamicLayoutBoxModelComponent } from '../../../../models/dynamic-layout-box-component.model';
+
+@Component({
+  selector: 'ds-dynamic-layout-collection-box',
+  templateUrl: './dynamic-layout-collection-box.component.html',
+  styleUrls: ['./dynamic-layout-collection-box.component.scss'],
+  imports: [
+    AsyncPipe,
+    NgClass,
+    RouterLink,
+    TranslateModule,
+  ],
+})
+export class DynamicLayoutCollectionBoxComponent extends DynamicLayoutBoxModelComponent implements OnInit {
+
+  isInline = environment.layout.collectionsBox.isInline;
+
+  /**
+   * Amount of mapped collections that should be fetched at once.
+   */
+  pageSize = 5;
+
+  /**
+    * Last page of the mapped collections that has been fetched.
+    */
+  lastPage = 0;
+
+  /**
+   * Whether or not a page of mapped collections is currently being loaded.
+   */
+  isLoading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
+
+  /**
+   * Whether or not more pages of mapped collections are available.
+   */
+  hasMore$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
+
+  /**
+   * This includes the owning collection
+   */
+  owningCollection$: Observable<Collection>;
+
+  /**
+    * This includes the mapped collection
+    */
+  mappedCollections$: Observable<Collection[]> = of([]);
+
+  constructor(
+    protected translateService: TranslateService,
+    @Inject('boxProvider') public boxProvider: DynamicLayoutBox,
+    @Inject('itemProvider') public itemProvider: Item,
+    private cds: CollectionDataService,
+  ) {
+    super(translateService, boxProvider, itemProvider);
+  }
+
+  ngOnInit(): void {
+    super.ngOnInit();
+
+    this.owningCollection$ = this.item.owningCollection.pipe(
+      getFirstSucceededRemoteDataPayload(),
+      shareReplay({ refCount: false, bufferSize: 1 }),
+    );
+
+    this.handleLoadMore();
+  }
+
+  handleLoadMore() {
+    this.isLoading$.next(true);
+    const newMappedCollections$ = this.loadMappedCollectionPage();
+    this.mappedCollections$ = combineLatest([this.mappedCollections$, newMappedCollections$]).pipe(
+      map(([mappedCollections, newMappedCollections]: [Collection[], Collection[]]) => {
+        return [...mappedCollections, ...newMappedCollections].filter(collection => hasValue(collection));
+      }),
+    );
+  }
+
+  loadMappedCollectionPage(): Observable<Collection[]> {
+    return this.cds.findMappedCollectionsFor(this.item, Object.assign(new FindListOptions(), {
+      elementsPerPage: this.pageSize,
+      currentPage: this.lastPage + 1,
+    })).pipe(
+      getFirstCompletedRemoteData<PaginatedList<Collection>>(),
+
+      // update isLoading$
+      tap(() => this.isLoading$.next(false)),
+
+      getFirstSucceededRemoteDataPayload(),
+
+      // update lastPage
+      tap((response: PaginatedList<Collection>) => this.lastPage = response.currentPage),
+
+      // update hasMore$
+      tap((response: PaginatedList<Collection>) => this.hasMore$.next(this.lastPage < response.totalPages)),
+
+      getPaginatedListPayload<Collection>(),
+    );
+  }
+
+  /**
+   * Returns a string representing the style of field label if exists
+   */
+  get labelStyle(): string {
+    return environment.layout.collectionsBox.defaultCollectionsLabelColStyle;
+  }
+
+  /**
+   * Returns a string representing the style of field value if exists
+   */
+  get valueStyle(): string {
+    return environment.layout.collectionsBox.defaultCollectionsValueColStyle;
+  }
+
+  /**
+   * Returns a string representing the style of row if exists
+   */
+  get rowStyle(): string {
+    return environment.layout.collectionsBox.defaultCollectionsRowStyle;
+  }
+
+}