@gnggln/ng-ui-system 1.0.0-alpha.2 → 1.0.0-alpha.21

package/esm2022/modal/lib/components/modal/modal.service.mjs

@@ -0,0 +1,197 @@
+import { Injectable, inject } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Observable, map } from 'rxjs';
+import { UiConfirmDialogComponent } from './confirm-dialog.component';
+import * as i0 from "@angular/core";
+/** @internal Mappatura dimensione -> larghezza CSS per il pannello overlay. */
+const SIZE_WIDTH_MAP = {
+    sm: '400px',
+    md: '560px',
+    lg: '720px',
+    xl: '900px',
+    fullscreen: '95vw',
+};
+/**
+ * Servizio per aprire modali e dialoghi di conferma.
+ *
+ * Gestisce lo stacking intelligente: una modale regolare puo
+ * ospitare al massimo un dialogo di conferma sopra di se.
+ * Non e possibile stackare due modali regolari.
+ *
+ * @usageNotes
+ *
+ * ### Aprire una modale personalizzata
+ * ```typescript
+ * const ref = this.modalService.open(MyDialogComponent, {
+ *   size: 'lg',
+ *   data: { userId: 123 },
+ * });
+ *
+ * ref.afterClosed().subscribe(result => {
+ *   console.log('Risultato:', result);
+ * });
+ * ```
+ *
+ * ### Conferma rapida
+ * ```typescript
+ * this.modalService.confirm('Confermi questa azione?')
+ *   .subscribe(ok => { if (ok) this.procedi(); });
+ * ```
+ *
+ * ### Preset di conferma
+ * ```typescript
+ * this.modalService.confirmDelete('Progetto Alpha')
+ *   .subscribe(ok => { if (ok) this.elimina(); });
+ * ```
+ */
+export class UiModalService {
+    constructor() {
+        /** @internal Istanza MatDialog per la gestione overlay. */
+        this.dialog = inject(MatDialog);
+        /** @internal Stack delle modali regolari aperte. */
+        this._modalStack = [];
+        /** @internal Traccia se un dialogo di conferma e attualmente aperto. */
+        this._confirmOpen = false;
+    }
+    /**
+     * Apre una modale con un componente personalizzato.
+     *
+     * Il componente aperto puo iniettare `MAT_DIALOG_DATA` per accedere
+     * ai dati e `MatDialogRef` per chiudere la modale.
+     *
+     * @param component - Componente standalone da renderizzare nella modale
+     * @param config - Configurazione (dimensione, dati, comportamento)
+     * @returns Riferimento alla modale aperta
+     */
+    open(component, config) {
+        // Regola di stacking: non stackare due modali regolari
+        if (this._modalStack.length > 0) {
+            console.warn('[UiModalService] Una modale e gia aperta. ' +
+                'Usa confirm() per aprire un dialogo di conferma sopra la modale corrente.');
+        }
+        const size = config?.size || 'md';
+        const dialogConfig = {
+            width: SIZE_WIDTH_MAP[size],
+            maxWidth: size === 'fullscreen' ? '95vw' : '90vw',
+            maxHeight: size === 'fullscreen' ? '95vh' : '90vh',
+            height: size === 'fullscreen' ? '95vh' : undefined,
+            disableClose: config?.disableClose ?? false,
+            autoFocus: true,
+            restoreFocus: true,
+            data: config?.data,
+            panelClass: ['ui-modal-panel', `ui-modal-panel--${size}`, ...(config?.panelClass ? [config.panelClass] : [])],
+            hasBackdrop: true,
+            backdropClass: ['cdk-overlay-dark-backdrop', 'ui-modal-backdrop'],
+        };
+        const ref = this.dialog.open(component, dialogConfig);
+        this._modalStack.push(ref);
+        ref.afterClosed().subscribe(() => {
+            this._modalStack = this._modalStack.filter((r) => r !== ref);
+        });
+        return ref;
+    }
+    /**
+     * Apre un dialogo di conferma.
+     *
+     * Accetta una stringa semplice (messaggio) o un oggetto di
+     * configurazione completo. Puo essere aperto sopra una modale
+     * esistente (stacking consentito).
+     *
+     * @param messageOrConfig - Messaggio o configurazione completa
+     * @returns Observable che emette `true` se confermato, `false` se annullato
+     */
+    confirm(messageOrConfig) {
+        const data = typeof messageOrConfig === 'string' ? { message: messageOrConfig } : messageOrConfig;
+        // Un solo dialogo di conferma alla volta
+        if (this._confirmOpen) {
+            console.warn('[UiModalService] Un dialogo di conferma e gia aperto.');
+            return new Observable((subscriber) => {
+                subscriber.next(false);
+                subscriber.complete();
+            });
+        }
+        this._confirmOpen = true;
+        const dialogConfig = {
+            width: '420px',
+            maxWidth: '90vw',
+            disableClose: false,
+            autoFocus: false,
+            restoreFocus: true,
+            data,
+            panelClass: ['ui-confirm-panel'],
+            hasBackdrop: true,
+            backdropClass: this._modalStack.length > 0
+                ? ['cdk-overlay-dark-backdrop', 'ui-confirm-backdrop--stacked']
+                : ['cdk-overlay-dark-backdrop', 'ui-modal-backdrop'],
+        };
+        const ref = this.dialog.open(UiConfirmDialogComponent, dialogConfig);
+        return ref.afterClosed().pipe(map((result) => {
+            this._confirmOpen = false;
+            return !!result;
+        }));
+    }
+    /**
+     * Scorciatoia: conferma eliminazione.
+     * Variante `delete` con icona cestino e pulsante warn.
+     *
+     * @param itemName - Nome opzionale dell'elemento da eliminare
+     */
+    confirmDelete(itemName) {
+        return this.confirm({
+            title: 'Conferma eliminazione',
+            message: itemName
+                ? `Sei sicuro di voler eliminare "${itemName}"? Questa azione non puo essere annullata.`
+                : 'Sei sicuro di voler eliminare questo elemento? Questa azione non puo essere annullata.',
+            confirmText: 'Elimina',
+            cancelText: 'Annulla',
+            variant: 'delete',
+        });
+    }
+    /**
+     * Scorciatoia: conferma abbandono modifiche.
+     * Variante `warn` con icona avviso.
+     */
+    confirmDiscard() {
+        return this.confirm({
+            title: 'Modifiche non salvate',
+            message: 'Ci sono modifiche non salvate. Sei sicuro di voler uscire senza salvare?',
+            confirmText: 'Esci senza salvare',
+            cancelText: 'Rimani',
+            variant: 'warn',
+        });
+    }
+    /**
+     * Scorciatoia: conferma salvataggio.
+     * Variante `confirm` con icona check.
+     */
+    confirmSave() {
+        return this.confirm({
+            title: 'Conferma salvataggio',
+            message: 'Sei sicuro di voler salvare le modifiche?',
+            confirmText: 'Salva',
+            cancelText: 'Annulla',
+            variant: 'confirm',
+        });
+    }
+    /** Chiude tutte le modali e dialoghi aperti. */
+    closeAll() {
+        this.dialog.closeAll();
+        this._modalStack = [];
+        this._confirmOpen = false;
+    }
+    /** Indica se ci sono modali o dialoghi attualmente aperti. */
+    get hasOpenDialogs() {
+        return this.dialog.openDialogs.length > 0;
+    }
+    /** Numero di modali regolari attualmente aperte. */
+    get openModalCount() {
+        return this._modalStack.length;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiModalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/modal/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, Type } from '@angular/core';\r\nimport { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';\r\nimport { Observable, map } from 'rxjs';\r\nimport { UiConfirmDialogComponent } from './confirm-dialog.component';\r\nimport { UiConfirmDialogData, UiModalOpenConfig, UiModalSize } from './modal.types';\r\n\r\n/** @internal Mappatura dimensione -> larghezza CSS per il pannello overlay. */\r\nconst SIZE_WIDTH_MAP: Record<UiModalSize, string> = {\r\n  sm: '400px',\r\n  md: '560px',\r\n  lg: '720px',\r\n  xl: '900px',\r\n  fullscreen: '95vw',\r\n};\r\n\r\n/**\r\n * Servizio per aprire modali e dialoghi di conferma.\r\n *\r\n * Gestisce lo stacking intelligente: una modale regolare puo\r\n * ospitare al massimo un dialogo di conferma sopra di se.\r\n * Non e possibile stackare due modali regolari.\r\n *\r\n * @usageNotes\r\n *\r\n * ### Aprire una modale personalizzata\r\n * ```typescript\r\n * const ref = this.modalService.open(MyDialogComponent, {\r\n *   size: 'lg',\r\n *   data: { userId: 123 },\r\n * });\r\n *\r\n * ref.afterClosed().subscribe(result => {\r\n *   console.log('Risultato:', result);\r\n * });\r\n * ```\r\n *\r\n * ### Conferma rapida\r\n * ```typescript\r\n * this.modalService.confirm('Confermi questa azione?')\r\n *   .subscribe(ok => { if (ok) this.procedi(); });\r\n * ```\r\n *\r\n * ### Preset di conferma\r\n * ```typescript\r\n * this.modalService.confirmDelete('Progetto Alpha')\r\n *   .subscribe(ok => { if (ok) this.elimina(); });\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiModalService {\r\n  /** @internal Istanza MatDialog per la gestione overlay. */\r\n  private readonly dialog = inject(MatDialog);\r\n\r\n  /** @internal Stack delle modali regolari aperte. */\r\n  private _modalStack: MatDialogRef<unknown>[] = [];\r\n\r\n  /** @internal Traccia se un dialogo di conferma e attualmente aperto. */\r\n  private _confirmOpen = false;\r\n\r\n  /**\r\n   * Apre una modale con un componente personalizzato.\r\n   *\r\n   * Il componente aperto puo iniettare `MAT_DIALOG_DATA` per accedere\r\n   * ai dati e `MatDialogRef` per chiudere la modale.\r\n   *\r\n   * @param component - Componente standalone da renderizzare nella modale\r\n   * @param config - Configurazione (dimensione, dati, comportamento)\r\n   * @returns Riferimento alla modale aperta\r\n   */\r\n  open<T, D = unknown, R = unknown>(component: Type<T>, config?: UiModalOpenConfig<D>): MatDialogRef<T, R> {\r\n    // Regola di stacking: non stackare due modali regolari\r\n    if (this._modalStack.length > 0) {\r\n      console.warn(\r\n        '[UiModalService] Una modale e gia aperta. ' +\r\n          'Usa confirm() per aprire un dialogo di conferma sopra la modale corrente.',\r\n      );\r\n    }\r\n\r\n    const size = config?.size || 'md';\r\n\r\n    const dialogConfig: MatDialogConfig<D> = {\r\n      width: SIZE_WIDTH_MAP[size],\r\n      maxWidth: size === 'fullscreen' ? '95vw' : '90vw',\r\n      maxHeight: size === 'fullscreen' ? '95vh' : '90vh',\r\n      height: size === 'fullscreen' ? '95vh' : undefined,\r\n      disableClose: config?.disableClose ?? false,\r\n      autoFocus: true,\r\n      restoreFocus: true,\r\n      data: config?.data as D,\r\n      panelClass: ['ui-modal-panel', `ui-modal-panel--${size}`, ...(config?.panelClass ? [config.panelClass] : [])],\r\n      hasBackdrop: true,\r\n      backdropClass: ['cdk-overlay-dark-backdrop', 'ui-modal-backdrop'],\r\n    };\r\n\r\n    const ref = this.dialog.open(component, dialogConfig) as MatDialogRef<T, R>;\r\n\r\n    this._modalStack.push(ref as MatDialogRef<unknown>);\r\n    ref.afterClosed().subscribe(() => {\r\n      this._modalStack = this._modalStack.filter((r) => r !== (ref as MatDialogRef<unknown>));\r\n    });\r\n\r\n    return ref;\r\n  }\r\n\r\n  /**\r\n   * Apre un dialogo di conferma.\r\n   *\r\n   * Accetta una stringa semplice (messaggio) o un oggetto di\r\n   * configurazione completo. Puo essere aperto sopra una modale\r\n   * esistente (stacking consentito).\r\n   *\r\n   * @param messageOrConfig - Messaggio o configurazione completa\r\n   * @returns Observable che emette `true` se confermato, `false` se annullato\r\n   */\r\n  confirm(messageOrConfig: string | UiConfirmDialogData): Observable<boolean> {\r\n    const data: UiConfirmDialogData =\r\n      typeof messageOrConfig === 'string' ? { message: messageOrConfig } : messageOrConfig;\r\n\r\n    // Un solo dialogo di conferma alla volta\r\n    if (this._confirmOpen) {\r\n      console.warn('[UiModalService] Un dialogo di conferma e gia aperto.');\r\n      return new Observable((subscriber) => {\r\n        subscriber.next(false);\r\n        subscriber.complete();\r\n      });\r\n    }\r\n\r\n    this._confirmOpen = true;\r\n\r\n    const dialogConfig: MatDialogConfig<UiConfirmDialogData> = {\r\n      width: '420px',\r\n      maxWidth: '90vw',\r\n      disableClose: false,\r\n      autoFocus: false,\r\n      restoreFocus: true,\r\n      data,\r\n      panelClass: ['ui-confirm-panel'],\r\n      hasBackdrop: true,\r\n      backdropClass:\r\n        this._modalStack.length > 0\r\n          ? ['cdk-overlay-dark-backdrop', 'ui-confirm-backdrop--stacked']\r\n          : ['cdk-overlay-dark-backdrop', 'ui-modal-backdrop'],\r\n    };\r\n\r\n    const ref = this.dialog.open(UiConfirmDialogComponent, dialogConfig);\r\n\r\n    return ref.afterClosed().pipe(\r\n      map((result) => {\r\n        this._confirmOpen = false;\r\n        return !!result;\r\n      }),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Scorciatoia: conferma eliminazione.\r\n   * Variante `delete` con icona cestino e pulsante warn.\r\n   *\r\n   * @param itemName - Nome opzionale dell'elemento da eliminare\r\n   */\r\n  confirmDelete(itemName?: string): Observable<boolean> {\r\n    return this.confirm({\r\n      title: 'Conferma eliminazione',\r\n      message: itemName\r\n        ? `Sei sicuro di voler eliminare \"${itemName}\"? Questa azione non puo essere annullata.`\r\n        : 'Sei sicuro di voler eliminare questo elemento? Questa azione non puo essere annullata.',\r\n      confirmText: 'Elimina',\r\n      cancelText: 'Annulla',\r\n      variant: 'delete',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Scorciatoia: conferma abbandono modifiche.\r\n   * Variante `warn` con icona avviso.\r\n   */\r\n  confirmDiscard(): Observable<boolean> {\r\n    return this.confirm({\r\n      title: 'Modifiche non salvate',\r\n      message: 'Ci sono modifiche non salvate. Sei sicuro di voler uscire senza salvare?',\r\n      confirmText: 'Esci senza salvare',\r\n      cancelText: 'Rimani',\r\n      variant: 'warn',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Scorciatoia: conferma salvataggio.\r\n   * Variante `confirm` con icona check.\r\n   */\r\n  confirmSave(): Observable<boolean> {\r\n    return this.confirm({\r\n      title: 'Conferma salvataggio',\r\n      message: 'Sei sicuro di voler salvare le modifiche?',\r\n      confirmText: 'Salva',\r\n      cancelText: 'Annulla',\r\n      variant: 'confirm',\r\n    });\r\n  }\r\n\r\n  /** Chiude tutte le modali e dialoghi aperti. */\r\n  closeAll(): void {\r\n    this.dialog.closeAll();\r\n    this._modalStack = [];\r\n    this._confirmOpen = false;\r\n  }\r\n\r\n  /** Indica se ci sono modali o dialoghi attualmente aperti. */\r\n  get hasOpenDialogs(): boolean {\r\n    return this.dialog.openDialogs.length > 0;\r\n  }\r\n\r\n  /** Numero di modali regolari attualmente aperte. */\r\n  get openModalCount(): number {\r\n    return this._modalStack.length;\r\n  }\r\n}\r\n"]}

package/esm2022/modal/lib/components/modal/modal.types.mjs

@@ -0,0 +1,6 @@
+/**
+ * @module ng-ui-system/modal
+ * Tipi e interfacce per UiModal, UiConfirmDialog e UiModalService.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/lib/core/types/index.mjs

@@ -0,0 +1,6 @@
+/**
+ * Shared types for ng-ui-system components.
+ * These types are used across multiple components to ensure consistency.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/core/types/index.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\r\n * Shared types for ng-ui-system components.\r\n * These types are used across multiple components to ensure consistency.\r\n */\r\n\r\n/** Standard size variants used across components. */\r\nexport type UiSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';\r\n\r\n/** Visual style variants for components. */\r\nexport type UiVariant = 'primary' | 'accent' | 'warn' | 'neutral' | 'ghost' | 'outline';\r\n\r\n/** Semantic color palette tokens. */\r\nexport type UiColor = 'primary' | 'accent' | 'warn' | 'success' | 'info' | 'neutral';\r\n\r\n/** Layout direction. */\r\nexport type UiDirection = 'horizontal' | 'vertical';\r\n\r\n/** Horizontal alignment. */\r\nexport type UiAlign = 'start' | 'center' | 'end' | 'stretch';\r\n\r\n/** Component density options for compact or spacious layouts. */\r\nexport type UiDensity = 'compact' | 'default' | 'comfortable';\r\n\r\n/**\r\n * Common Lucide icon names with autocomplete support.\r\n * Accepts any valid Lucide icon name as a string.\r\n *\r\n * Provides IntelliSense for the most frequently used enterprise icons.\r\n * For the full icon catalogue, visit https://lucide.dev/icons\r\n *\r\n * @example\r\n * ```typescript\r\n * const myIcon: UiIconName = 'arrow-right';  // autocomplete ✓\r\n * const custom: UiIconName = 'my-custom-icon'; // still valid\r\n * ```\r\n */\r\nexport type UiIconName =\r\n  // ── Navigation ──\r\n  | 'arrow-right'\r\n  | 'arrow-left'\r\n  | 'arrow-up'\r\n  | 'arrow-down'\r\n  | 'chevron-right'\r\n  | 'chevron-left'\r\n  | 'chevron-up'\r\n  | 'chevron-down'\r\n  | 'external-link'\r\n  | 'corner-down-left'\r\n  | 'corner-down-right'\r\n  // ── Actions ──\r\n  | 'check'\r\n  | 'x'\r\n  | 'plus'\r\n  | 'minus'\r\n  | 'search'\r\n  | 'refresh-cw'\r\n  | 'download'\r\n  | 'upload'\r\n  | 'save'\r\n  | 'trash-2'\r\n  | 'pencil'\r\n  | 'copy'\r\n  | 'clipboard'\r\n  | 'share-2'\r\n  | 'send'\r\n  | 'log-in'\r\n  | 'log-out'\r\n  // ── Communication ──\r\n  | 'mail'\r\n  | 'message-circle'\r\n  | 'phone'\r\n  | 'bell'\r\n  // ── Users & Identity ──\r\n  | 'user'\r\n  | 'users'\r\n  | 'lock'\r\n  | 'unlock'\r\n  | 'key'\r\n  | 'shield'\r\n  // ── Files & Media ──\r\n  | 'file'\r\n  | 'file-text'\r\n  | 'file-spreadsheet'\r\n  | 'file-archive'\r\n  | 'folder'\r\n  | 'image'\r\n  | 'camera'\r\n  | 'paperclip'\r\n  // ── Feedback & Status ──\r\n  | 'info'\r\n  | 'alert-triangle'\r\n  | 'alert-circle'\r\n  | 'check-circle'\r\n  | 'x-circle'\r\n  | 'help-circle'\r\n  | 'loader-2'\r\n  // ── Layout & UI ──\r\n  | 'menu'\r\n  | 'more-horizontal'\r\n  | 'more-vertical'\r\n  | 'grid'\r\n  | 'list'\r\n  | 'filter'\r\n  | 'sliders'\r\n  | 'columns'\r\n  | 'maximize-2'\r\n  | 'minimize-2'\r\n  // ── Misc ──\r\n  | 'home'\r\n  | 'settings'\r\n  | 'star'\r\n  | 'heart'\r\n  | 'bookmark'\r\n  | 'calendar'\r\n  | 'clock'\r\n  | 'map-pin'\r\n  | 'eye'\r\n  | 'eye-off'\r\n  | 'sun'\r\n  | 'moon'\r\n  | 'monitor'\r\n  // ── Accepts any string for custom / unlisted icons ──\r\n  | (string & Record<never, never>);\r\n\r\n/** Status values used for feedback components (badges, alerts, indicators). */\r\nexport type UiStatus = 'idle' | 'loading' | 'success' | 'error' | 'warning' | 'info';\r\n\r\n/**\r\n * Generic key-value pair used in select options, dropdowns, etc.\r\n * @template T - The type of the value.\r\n */\r\nexport interface UiOption<T = string> {\r\n  /** The display label. */\r\n  label: string;\r\n  /** The underlying value. */\r\n  value: T;\r\n  /** Whether this option is disabled. */\r\n  disabled?: boolean;\r\n  /** Optional icon name (Lucide icon). */\r\n  icon?: UiIconName;\r\n  /** Optional grouping key for grouped selects. */\r\n  group?: string;\r\n}\r\n\r\n/**\r\n * Result wrapper for async operations.\r\n * @template T - The type of the data payload.\r\n */\r\nexport interface UiAsyncState<T = unknown> {\r\n  status: UiStatus;\r\n  data: T | null;\r\n  error: string | null;\r\n}\r\n\r\n// ── Toast ────────────────────────────────────────────────────────────\r\n\r\n/** Toast notification type. */\r\nexport type UiToastType = 'success' | 'error' | 'warning' | 'info';\r\n\r\n// ── Endpoint / HTTP ──────────────────────────────────────────────────\r\n\r\n/** Messages configuration for an endpoint (inline, no label archive). */\r\nexport interface UiEndpointMessages {\r\n  /** Success toast message. Supports `${key}` placeholders replaced at runtime. */\r\n  success?: string;\r\n  /** Error toast message. Supports `${key}` placeholders replaced at runtime. */\r\n  error?: string;\r\n}\r\n\r\n/**\r\n * Extracts a custom error message from the HTTP error response.\r\n * Return `null` to fall back to the default message.\r\n */\r\nexport type UiErrorExtractor = (error: any) => string | null;\r\n\r\n/**\r\n * Dynamically resolves a success message at runtime.\r\n * Return `null` to fall back to the default message.\r\n */\r\nexport type UiSuccessResolver = () => string | null;\r\n\r\n/**\r\n * Query parameters for URL building.\r\n * Keys map to query param names; values are auto-converted to strings.\r\n */\r\nexport type UiQueryParameters = Record<string, string | string[] | number | number[] | boolean>;\r\n\r\n/**\r\n * Endpoint configuration for `UiHttpService`.\r\n *\r\n * Each endpoint defines its URL, optional inline messages, and\r\n * toast/error behaviour. All toast flags default to `false` (opt-in).\r\n *\r\n * @usageNotes\r\n * ### Basic endpoint factory\r\n * ```typescript\r\n * const SAVE_USER = (): UiEndpoint => ({\r\n *   url: '/api/users',\r\n *   id: 'user_save',\r\n *   showSuccess: true,\r\n *   messages: { success: 'Utente salvato!' },\r\n * });\r\n * ```\r\n *\r\n * ### Dynamic endpoint with replacements\r\n * ```typescript\r\n * const UPDATE_ITEM = (id: number): UiEndpoint => ({\r\n *   url: `/api/items/${id}`,\r\n *   id: 'item_update',\r\n *   showSuccess: true,\r\n *   showError: true,\r\n *   messages: {\r\n *     success: 'Elemento ${name} aggiornato',\r\n *     error: 'Errore aggiornamento elemento',\r\n *   },\r\n *   replacements: { name: 'Widget' },\r\n * });\r\n * ```\r\n */\r\nexport interface UiEndpoint {\r\n  /** Relative or absolute URL for the API call. */\r\n  url: string;\r\n  /** Unique identifier for the endpoint (used for debounce keying). */\r\n  id: string;\r\n  /** Whether to show a success toast on completion. Default: `false`. */\r\n  showSuccess?: boolean;\r\n  /** Whether to show an error toast on failure. Default: `false`. */\r\n  showError?: boolean;\r\n  /** Inline messages for success/error toasts. */\r\n  messages?: UiEndpointMessages;\r\n  /** Placeholder replacements for message strings (`${key}` → value). */\r\n  replacements?: Record<string, string | number>;\r\n  /** Custom error message extractor from the HTTP error response. */\r\n  errorExtractor?: UiErrorExtractor;\r\n  /** Custom success message resolver (overrides inline message). */\r\n  successMessageResolver?: UiSuccessResolver;\r\n  /** Whether this endpoint should be tracked by BlackBox. Default: `true`. */\r\n  trackable?: boolean;\r\n}\r\n"]}

package/esm2022/page-header/entry-page-header.mjs

@@ -0,0 +1,5 @@
+/**
+ * Bootstrap del secondary entry `@gnggln/ng-ui-system/page-header`. Page Header e breadcrumb.
+ */
+export * from './lib/components/page-header/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cnktcGFnZS1oZWFkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2VudHJ5LXBhZ2UtaGVhZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQm9vdHN0cmFwIGRlbCBzZWNvbmRhcnkgZW50cnkgYEBnbmdnbG4vbmctdWktc3lzdGVtL3BhZ2UtaGVhZGVyYC4gUGFnZSBIZWFkZXIgZSBicmVhZGNydW1iLlxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3BhZ2UtaGVhZGVyL2luZGV4JztcblxuIl19

package/esm2022/page-header/gnggln-ng-ui-system-page-header.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './entry-page-header';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ25nZ2xuLW5nLXVpLXN5c3RlbS1wYWdlLWhlYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL25nLXVpLXN5c3RlbS9zcmMvZ25nZ2xuLW5nLXVpLXN5c3RlbS1wYWdlLWhlYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZW50cnktcGFnZS1oZWFkZXInO1xuIl19

package/esm2022/page-header/lib/components/page-header/breadcrumb.service.mjs

@@ -0,0 +1,243 @@
+/** biome-ignore-all lint/complexity/useLiteralKeys: <explanation> */
+import { Injectable, inject } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { UI_BREADCRUMB_LABEL_RESOLVER, } from './page-header.types';
+import * as i0 from "@angular/core";
+/**
+ * Service that builds a nested breadcrumb trail from Angular route configuration.
+ *
+ * Routes must define `data.id`, `data.title`, and optionally `data.breadcrumbs`
+ * (an array of parent route IDs) for the chain to resolve correctly.
+ *
+ * Supports lazy-loaded routes: the internal route map is rebuilt automatically
+ * whenever new routes are loaded via `NavigationEnd`.
+ *
+ * Label resolution for route parameters (`:param`) is delegated to an injectable
+ * `UiLabelResolverFn` via the `UI_BREADCRUMB_LABEL_RESOLVER` token.
+ *
+ * @usageNotes
+ * ### Route configuration
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'users',
+ *     data: { id: 'users', title: 'Utenti' },
+ *     children: [
+ *       {
+ *         path: ':userId',
+ *         data: { id: 'user-detail', title: ':userId', breadcrumbs: ['users'] },
+ *         component: UserDetailComponent,
+ *       },
+ *     ],
+ *   },
+ * ];
+ * ```
+ *
+ * ### Custom label resolver
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: UI_BREADCRUMB_LABEL_RESOLVER,
+ *     useValue: (name: string, value: string) =>
+ *       name === 'userId' ? `User #${value}` : value,
+ *   },
+ * ]
+ * ```
+ */
+export class UiBreadcrumbService {
+    constructor() {
+        this.router = inject(Router);
+        this.labelResolver = inject(UI_BREADCRUMB_LABEL_RESOLVER);
+        /** @internal Map of route ID → breadcrumb configuration. */
+        this.breadcrumbMap = new Map();
+        /** @internal Tracks route count to detect lazy-loaded route additions. */
+        this.lastRouteConfigLength = 0;
+        /** @internal Last computed breadcrumbs for navigateBack. */
+        this.lastBreadcrumbs = [];
+        this.rebuildRouteMap();
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => this.rebuildRouteMapIfNeeded());
+    }
+    /**
+     * Computes the breadcrumb trail for the currently active route.
+     *
+     * @param route - The root `ActivatedRoute` (typically injected in the component).
+     * @returns Ordered array of breadcrumb items from root to current route.
+     */
+    getBreadcrumbsForRoute(route) {
+        let deepestRoute = route;
+        while (deepestRoute.firstChild) {
+            deepestRoute = deepestRoute.firstChild;
+        }
+        let routeWithId = deepestRoute;
+        while (routeWithId && !routeWithId.snapshot.data['id']) {
+            routeWithId = routeWithId.parent;
+        }
+        const routeId = routeWithId?.snapshot.data['id'];
+        if (!routeId) {
+            this.lastBreadcrumbs = [];
+            return [];
+        }
+        const params = this.collectParamsFromPath(deepestRoute);
+        const breadcrumbs = this.buildBreadcrumbChain(routeId, params);
+        this.lastBreadcrumbs = breadcrumbs;
+        return breadcrumbs;
+    }
+    /**
+     * Navigates to the previous breadcrumb (parent route).
+     * Falls back to `fallbackUrl` (default: `/`) when no parent exists.
+     */
+    navigateBack(fallbackUrl = '/') {
+        const prev = this.lastBreadcrumbs.length > 1 ? this.lastBreadcrumbs[this.lastBreadcrumbs.length - 2] : null;
+        const target = prev?.url ?? fallbackUrl;
+        this.router.navigateByUrl(target);
+    }
+    /** @internal Collects all route params from the full path (including parents). */
+    collectParamsFromPath(route) {
+        const params = {};
+        for (const r of route.pathFromRoot) {
+            Object.assign(params, r.snapshot.params);
+        }
+        return params;
+    }
+    // ─── Private helpers ─────────────────────────────────────────────
+    /** @internal Rebuilds the map only when new lazy routes appear. */
+    rebuildRouteMapIfNeeded() {
+        const currentLength = this.countRoutes(this.router.config);
+        if (currentLength !== this.lastRouteConfigLength) {
+            this.rebuildRouteMap();
+        }
+    }
+    /** @internal Recursively counts routes including lazy-loaded children. */
+    countRoutes(routes) {
+        let count = routes.length;
+        for (const route of routes) {
+            if (route.children) {
+                count += this.countRoutes(route.children);
+            }
+            if (route._loadedRoutes) {
+                count += this.countRoutes(route._loadedRoutes);
+            }
+        }
+        return count;
+    }
+    /** @internal Clears and rebuilds the full route → breadcrumb map. */
+    rebuildRouteMap() {
+        this.breadcrumbMap.clear();
+        this.buildRouteMap(this.router.config);
+        this.lastRouteConfigLength = this.countRoutes(this.router.config);
+    }
+    /** @internal Recursively walks route tree to build the breadcrumb map. */
+    buildRouteMap(routes, parentPath = '') {
+        for (const route of routes) {
+            const currentPath = `${parentPath}/${route.path || ''}`;
+            if (route.data?.['id']) {
+                const fullPath = this.normalizePath(currentPath);
+                this.breadcrumbMap.set(route.data['id'], {
+                    id: route.data['id'],
+                    path: fullPath,
+                    label: route.data['title'] || route.path || route.data['id'],
+                    parentIds: route.data['breadcrumbs'] || [],
+                    metadata: route.data,
+                });
+            }
+            if (route.children) {
+                this.buildRouteMap(route.children, currentPath);
+            }
+            if (route._loadedRoutes) {
+                this.buildRouteMap(route._loadedRoutes, currentPath);
+            }
+        }
+    }
+    /** @internal Builds the full breadcrumb chain for a route by its ID. */
+    buildBreadcrumbChain(routeId, params) {
+        const config = this.breadcrumbMap.get(routeId);
+        if (!config)
+            return [];
+        this.saveFullPath(routeId, this.router.url);
+        const parentChain = this.getParentChain(config.parentIds, params);
+        const breadcrumbs = [...parentChain];
+        breadcrumbs.push({
+            label: this.resolveLabel(config.label, params),
+            url: this.stripQueryParams(this.router.url),
+            isLast: true,
+        });
+        return breadcrumbs;
+    }
+    /** @internal Resolves parent breadcrumbs from ordered parent IDs. */
+    getParentChain(parentIds, params) {
+        if (!parentIds?.length)
+            return [];
+        return parentIds
+            .map((id) => {
+            const config = this.breadcrumbMap.get(id);
+            if (!config)
+                return null;
+            return {
+                label: this.resolveLabel(config.label, params),
+                url: this.resolveUrl(config.path, params),
+                isLast: false,
+            };
+        })
+            .filter(Boolean);
+    }
+    /**
+     * @internal Resolves `:param` placeholders in a label using
+     * the injected label resolver function.
+     */
+    resolveLabel(label, params) {
+        if (!label.includes(':'))
+            return label;
+        let resolved = label;
+        for (const [key, value] of Object.entries(params)) {
+            const readableValue = this.labelResolver(key, value);
+            resolved = resolved.replace(`:${key}`, readableValue);
+        }
+        return resolved;
+    }
+    /** @internal Resolves `:param` placeholders in a path and creates a URL. */
+    resolveUrl(path, params) {
+        let processedPath = path;
+        if (path.includes(':')) {
+            const segments = path.split('/');
+            const processedSegments = segments.map((segment) => {
+                if (segment.startsWith(':')) {
+                    const paramName = segment.substring(1);
+                    return params[paramName] || segment;
+                }
+                return segment;
+            });
+            processedPath = processedSegments.join('/');
+        }
+        try {
+            return this.router.createUrlTree([processedPath]).toString();
+        }
+        catch {
+            return processedPath;
+        }
+    }
+    /** @internal Normalizes path by collapsing double slashes and trimming trailing slash. */
+    normalizePath(path) {
+        return path.replace(/\/+/g, '/').replace(/\/$/, '');
+    }
+    /** @internal Removes query parameters from a URL. */
+    stripQueryParams(url) {
+        return url.split('?')[0];
+    }
+    /** @internal Caches the fully resolved URL for a route ID. */
+    saveFullPath(routeId, fullPath) {
+        const config = this.breadcrumbMap.get(routeId);
+        if (config) {
+            config.fullPath = this.stripQueryParams(fullPath);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBreadcrumbService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBreadcrumbService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBreadcrumbService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/page-header/breadcrumb.service.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAuB,aAAa,EAAE,MAAM,EAAe,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EACL,4BAA4B,GAG7B,MAAM,qBAAqB,CAAC;;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,MAAM,OAAO,mBAAmB;IAW9B;QAViB,WAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACxB,kBAAa,GAAG,MAAM,CAAC,4BAA4B,CAAC,CAAC;QAEtE,4DAA4D;QACpD,kBAAa,GAAG,IAAI,GAAG,EAA8B,CAAC;QAC9D,0EAA0E;QAClE,0BAAqB,GAAG,CAAC,CAAC;QAClC,4DAA4D;QACpD,oBAAe,GAAuB,EAAE,CAAC;QAG/C,IAAI,CAAC,eAAe,EAAE,CAAC;QAEvB,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,aAAa,CAAC,CAAC;aACvD,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,sBAAsB,CAAC,KAAqB;QAC1C,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;YAC/B,YAAY,GAAG,YAAY,CAAC,UAAU,CAAC;QACzC,CAAC;QAED,IAAI,WAAW,GAA0B,YAAY,CAAC;QACtD,OAAO,WAAW,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;QACnC,CAAC;QACD,MAAM,OAAO,GAAG,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC;QACxD,MAAM,WAAW,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC/D,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,WAAW,GAAG,GAAG;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC5G,MAAM,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,WAAW,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,kFAAkF;IAC1E,qBAAqB,CAAC,KAAqB;QACjD,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACnC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,oEAAoE;IAEpE,mEAAmE;IAC3D,uBAAuB;QAC7B,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,aAAa,KAAK,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACjD,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAED,0EAA0E;IAClE,WAAW,CAAC,MAAc;QAChC,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;QAC1B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACnB,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC5C,CAAC;YACD,IAAK,KAAa,CAAC,aAAa,EAAE,CAAC;gBACjC,KAAK,IAAI,IAAI,CAAC,WAAW,CAAE,KAAa,CAAC,aAAa,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,qEAAqE;IAC7D,eAAe;QACrB,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACpE,CAAC;IAED,0EAA0E;IAClE,aAAa,CAAC,MAAc,EAAE,UAAU,GAAG,EAAE;QACnD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,WAAW,GAAG,GAAG,UAAU,IAAI,KAAK,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;YAExD,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;gBACjD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;oBACvC,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;oBACpB,IAAI,EAAE,QAAQ;oBACd,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;oBAC5D,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;oBAC1C,QAAQ,EAAE,KAAK,CAAC,IAAI;iBACrB,CAAC,CAAC;YACL,CAAC;YAED,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACnB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;YAClD,CAAC;YACD,IAAK,KAAa,CAAC,aAAa,EAAE,CAAC;gBACjC,IAAI,CAAC,aAAa,CAAE,KAAa,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;IACH,CAAC;IAED,wEAAwE;IAChE,oBAAoB,CAAC,OAAe,EAAE,MAA8B;QAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC/C,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QAEvB,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAE5C,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAClE,MAAM,WAAW,GAAuB,CAAC,GAAG,WAAW,CAAC,CAAC;QAEzD,WAAW,CAAC,IAAI,CAAC;YACf,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC;YAC9C,GAAG,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;YAC3C,MAAM,EAAE,IAAI;SACb,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,qEAAqE;IAC7D,cAAc,CAAC,SAAmB,EAAE,MAA8B;QACxE,IAAI,CAAC,SAAS,EAAE,MAAM;YAAE,OAAO,EAAE,CAAC;QAElC,OAAO,SAAS;aACb,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE;YACV,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC1C,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YAEzB,OAAO;gBACL,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC;gBAC9C,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC;gBACzC,MAAM,EAAE,KAAK;aACd,CAAC;QACJ,CAAC,CAAC;aACD,MAAM,CAAC,OAAO,CAAuB,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACK,YAAY,CAAC,KAAa,EAAE,MAA8B;QAChE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAEvC,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAClD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACrD,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,GAAG,EAAE,EAAE,aAAa,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,4EAA4E;IACpE,UAAU,CAAC,IAAY,EAAE,MAA8B;QAC7D,IAAI,aAAa,GAAG,IAAI,CAAC;QAEzB,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACjC,MAAM,iBAAiB,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBACjD,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC5B,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;oBACvC,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC;gBACtC,CAAC;gBACD,OAAO,OAAO,CAAC;YACjB,CAAC,CAAC,CAAC;YACH,aAAa,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC9C,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC/D,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,aAAa,CAAC;QACvB,CAAC;IACH,CAAC;IAED,0FAA0F;IAClF,aAAa,CAAC,IAAY;QAChC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,qDAAqD;IAC7C,gBAAgB,CAAC,GAAW;QAClC,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED,8DAA8D;IACtD,YAAY,CAAC,OAAe,EAAE,QAAgB;QACpD,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC/C,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;+GArNU,mBAAmB;mHAAnB,mBAAmB,cADN,MAAM;;4FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/** biome-ignore-all lint/complexity/useLiteralKeys: <explanation> */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { type ActivatedRoute, NavigationEnd, Router, type Routes } from '@angular/router';\r\nimport { filter } from 'rxjs/operators';\r\nimport {\r\n  UI_BREADCRUMB_LABEL_RESOLVER,\r\n  type UiBreadcrumbConfig,\r\n  type UiBreadcrumbItem,\r\n} from './page-header.types';\r\n\r\n/**\r\n * Service that builds a nested breadcrumb trail from Angular route configuration.\r\n *\r\n * Routes must define `data.id`, `data.title`, and optionally `data.breadcrumbs`\r\n * (an array of parent route IDs) for the chain to resolve correctly.\r\n *\r\n * Supports lazy-loaded routes: the internal route map is rebuilt automatically\r\n * whenever new routes are loaded via `NavigationEnd`.\r\n *\r\n * Label resolution for route parameters (`:param`) is delegated to an injectable\r\n * `UiLabelResolverFn` via the `UI_BREADCRUMB_LABEL_RESOLVER` token.\r\n *\r\n * @usageNotes\r\n * ### Route configuration\r\n * ```typescript\r\n * const routes: Routes = [\r\n *   {\r\n *     path: 'users',\r\n *     data: { id: 'users', title: 'Utenti' },\r\n *     children: [\r\n *       {\r\n *         path: ':userId',\r\n *         data: { id: 'user-detail', title: ':userId', breadcrumbs: ['users'] },\r\n *         component: UserDetailComponent,\r\n *       },\r\n *     ],\r\n *   },\r\n * ];\r\n * ```\r\n *\r\n * ### Custom label resolver\r\n * ```typescript\r\n * providers: [\r\n *   {\r\n *     provide: UI_BREADCRUMB_LABEL_RESOLVER,\r\n *     useValue: (name: string, value: string) =>\r\n *       name === 'userId' ? `User #${value}` : value,\r\n *   },\r\n * ]\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiBreadcrumbService {\r\n  private readonly router = inject(Router);\r\n  private readonly labelResolver = inject(UI_BREADCRUMB_LABEL_RESOLVER);\r\n\r\n  /** @internal Map of route ID → breadcrumb configuration. */\r\n  private breadcrumbMap = new Map<string, UiBreadcrumbConfig>();\r\n  /** @internal Tracks route count to detect lazy-loaded route additions. */\r\n  private lastRouteConfigLength = 0;\r\n  /** @internal Last computed breadcrumbs for navigateBack. */\r\n  private lastBreadcrumbs: UiBreadcrumbItem[] = [];\r\n\r\n  constructor() {\r\n    this.rebuildRouteMap();\r\n\r\n    this.router.events\r\n      .pipe(filter((event) => event instanceof NavigationEnd))\r\n      .subscribe(() => this.rebuildRouteMapIfNeeded());\r\n  }\r\n\r\n  /**\r\n   * Computes the breadcrumb trail for the currently active route.\r\n   *\r\n   * @param route - The root `ActivatedRoute` (typically injected in the component).\r\n   * @returns Ordered array of breadcrumb items from root to current route.\r\n   */\r\n  getBreadcrumbsForRoute(route: ActivatedRoute): UiBreadcrumbItem[] {\r\n    let deepestRoute = route;\r\n    while (deepestRoute.firstChild) {\r\n      deepestRoute = deepestRoute.firstChild;\r\n    }\r\n\r\n    let routeWithId: ActivatedRoute | null = deepestRoute;\r\n    while (routeWithId && !routeWithId.snapshot.data['id']) {\r\n      routeWithId = routeWithId.parent;\r\n    }\r\n    const routeId = routeWithId?.snapshot.data['id'];\r\n    if (!routeId) {\r\n      this.lastBreadcrumbs = [];\r\n      return [];\r\n    }\r\n\r\n    const params = this.collectParamsFromPath(deepestRoute);\r\n    const breadcrumbs = this.buildBreadcrumbChain(routeId, params);\r\n    this.lastBreadcrumbs = breadcrumbs;\r\n    return breadcrumbs;\r\n  }\r\n\r\n  /**\r\n   * Navigates to the previous breadcrumb (parent route).\r\n   * Falls back to `fallbackUrl` (default: `/`) when no parent exists.\r\n   */\r\n  navigateBack(fallbackUrl = '/'): void {\r\n    const prev = this.lastBreadcrumbs.length > 1 ? this.lastBreadcrumbs[this.lastBreadcrumbs.length - 2] : null;\r\n    const target = prev?.url ?? fallbackUrl;\r\n    this.router.navigateByUrl(target);\r\n  }\r\n\r\n  /** @internal Collects all route params from the full path (including parents). */\r\n  private collectParamsFromPath(route: ActivatedRoute): Record<string, string> {\r\n    const params: Record<string, string> = {};\r\n    for (const r of route.pathFromRoot) {\r\n      Object.assign(params, r.snapshot.params);\r\n    }\r\n    return params;\r\n  }\r\n\r\n  // ─── Private helpers ─────────────────────────────────────────────\r\n\r\n  /** @internal Rebuilds the map only when new lazy routes appear. */\r\n  private rebuildRouteMapIfNeeded(): void {\r\n    const currentLength = this.countRoutes(this.router.config);\r\n    if (currentLength !== this.lastRouteConfigLength) {\r\n      this.rebuildRouteMap();\r\n    }\r\n  }\r\n\r\n  /** @internal Recursively counts routes including lazy-loaded children. */\r\n  private countRoutes(routes: Routes): number {\r\n    let count = routes.length;\r\n    for (const route of routes) {\r\n      if (route.children) {\r\n        count += this.countRoutes(route.children);\r\n      }\r\n      if ((route as any)._loadedRoutes) {\r\n        count += this.countRoutes((route as any)._loadedRoutes);\r\n      }\r\n    }\r\n    return count;\r\n  }\r\n\r\n  /** @internal Clears and rebuilds the full route → breadcrumb map. */\r\n  private rebuildRouteMap(): void {\r\n    this.breadcrumbMap.clear();\r\n    this.buildRouteMap(this.router.config);\r\n    this.lastRouteConfigLength = this.countRoutes(this.router.config);\r\n  }\r\n\r\n  /** @internal Recursively walks route tree to build the breadcrumb map. */\r\n  private buildRouteMap(routes: Routes, parentPath = ''): void {\r\n    for (const route of routes) {\r\n      const currentPath = `${parentPath}/${route.path || ''}`;\r\n\r\n      if (route.data?.['id']) {\r\n        const fullPath = this.normalizePath(currentPath);\r\n        this.breadcrumbMap.set(route.data['id'], {\r\n          id: route.data['id'],\r\n          path: fullPath,\r\n          label: route.data['title'] || route.path || route.data['id'],\r\n          parentIds: route.data['breadcrumbs'] || [],\r\n          metadata: route.data,\r\n        });\r\n      }\r\n\r\n      if (route.children) {\r\n        this.buildRouteMap(route.children, currentPath);\r\n      }\r\n      if ((route as any)._loadedRoutes) {\r\n        this.buildRouteMap((route as any)._loadedRoutes, currentPath);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** @internal Builds the full breadcrumb chain for a route by its ID. */\r\n  private buildBreadcrumbChain(routeId: string, params: Record<string, string>): UiBreadcrumbItem[] {\r\n    const config = this.breadcrumbMap.get(routeId);\r\n    if (!config) return [];\r\n\r\n    this.saveFullPath(routeId, this.router.url);\r\n\r\n    const parentChain = this.getParentChain(config.parentIds, params);\r\n    const breadcrumbs: UiBreadcrumbItem[] = [...parentChain];\r\n\r\n    breadcrumbs.push({\r\n      label: this.resolveLabel(config.label, params),\r\n      url: this.stripQueryParams(this.router.url),\r\n      isLast: true,\r\n    });\r\n\r\n    return breadcrumbs;\r\n  }\r\n\r\n  /** @internal Resolves parent breadcrumbs from ordered parent IDs. */\r\n  private getParentChain(parentIds: string[], params: Record<string, string>): UiBreadcrumbItem[] {\r\n    if (!parentIds?.length) return [];\r\n\r\n    return parentIds\r\n      .map((id) => {\r\n        const config = this.breadcrumbMap.get(id);\r\n        if (!config) return null;\r\n\r\n        return {\r\n          label: this.resolveLabel(config.label, params),\r\n          url: this.resolveUrl(config.path, params),\r\n          isLast: false,\r\n        };\r\n      })\r\n      .filter(Boolean) as UiBreadcrumbItem[];\r\n  }\r\n\r\n  /**\r\n   * @internal Resolves `:param` placeholders in a label using\r\n   * the injected label resolver function.\r\n   */\r\n  private resolveLabel(label: string, params: Record<string, string>): string {\r\n    if (!label.includes(':')) return label;\r\n\r\n    let resolved = label;\r\n    for (const [key, value] of Object.entries(params)) {\r\n      const readableValue = this.labelResolver(key, value);\r\n      resolved = resolved.replace(`:${key}`, readableValue);\r\n    }\r\n    return resolved;\r\n  }\r\n\r\n  /** @internal Resolves `:param` placeholders in a path and creates a URL. */\r\n  private resolveUrl(path: string, params: Record<string, string>): string {\r\n    let processedPath = path;\r\n\r\n    if (path.includes(':')) {\r\n      const segments = path.split('/');\r\n      const processedSegments = segments.map((segment) => {\r\n        if (segment.startsWith(':')) {\r\n          const paramName = segment.substring(1);\r\n          return params[paramName] || segment;\r\n        }\r\n        return segment;\r\n      });\r\n      processedPath = processedSegments.join('/');\r\n    }\r\n\r\n    try {\r\n      return this.router.createUrlTree([processedPath]).toString();\r\n    } catch {\r\n      return processedPath;\r\n    }\r\n  }\r\n\r\n  /** @internal Normalizes path by collapsing double slashes and trimming trailing slash. */\r\n  private normalizePath(path: string): string {\r\n    return path.replace(/\\/+/g, '/').replace(/\\/$/, '');\r\n  }\r\n\r\n  /** @internal Removes query parameters from a URL. */\r\n  private stripQueryParams(url: string): string {\r\n    return url.split('?')[0];\r\n  }\r\n\r\n  /** @internal Caches the fully resolved URL for a route ID. */\r\n  private saveFullPath(routeId: string, fullPath: string): void {\r\n    const config = this.breadcrumbMap.get(routeId);\r\n    if (config) {\r\n      config.fullPath = this.stripQueryParams(fullPath);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/page-header/lib/components/page-header/index.mjs

@@ -0,0 +1,20 @@
+/**
+ * ng-ui-system — Page Header entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiPageHeaderComponent,
+ *   UiBreadcrumbService,
+ *   UiBreadcrumbItem,
+ *   UI_BREADCRUMB_LABEL_RESOLVER,
+ * } from 'ng-ui-system';
+ * ```
+ */
+// Components
+export { UiPageHeaderComponent } from './page-header.component';
+// Services
+export { UiBreadcrumbService } from './breadcrumb.service';
+// Types & Tokens
+export { UI_BREADCRUMB_LABEL_RESOLVER, } from './page-header.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL3BhZ2UtaGVhZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7R0FZRztBQUVILGFBQWE7QUFDYixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVoRSxXQUFXO0FBQ1gsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFM0QsaUJBQWlCO0FBQ2pCLE9BQU8sRUFJTCw0QkFBNEIsR0FDN0IsTUFBTSxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBuZy11aS1zeXN0ZW0g4oCUIFBhZ2UgSGVhZGVyIGVudHJ5IHBvaW50LlxyXG4gKlxyXG4gKiBAZXhhbXBsZVxyXG4gKiBgYGB0eXBlc2NyaXB0XHJcbiAqIGltcG9ydCB7XHJcbiAqICAgVWlQYWdlSGVhZGVyQ29tcG9uZW50LFxyXG4gKiAgIFVpQnJlYWRjcnVtYlNlcnZpY2UsXHJcbiAqICAgVWlCcmVhZGNydW1iSXRlbSxcclxuICogICBVSV9CUkVBRENSVU1CX0xBQkVMX1JFU09MVkVSLFxyXG4gKiB9IGZyb20gJ25nLXVpLXN5c3RlbSc7XHJcbiAqIGBgYFxyXG4gKi9cclxuXHJcbi8vIENvbXBvbmVudHNcclxuZXhwb3J0IHsgVWlQYWdlSGVhZGVyQ29tcG9uZW50IH0gZnJvbSAnLi9wYWdlLWhlYWRlci5jb21wb25lbnQnO1xyXG5cclxuLy8gU2VydmljZXNcclxuZXhwb3J0IHsgVWlCcmVhZGNydW1iU2VydmljZSB9IGZyb20gJy4vYnJlYWRjcnVtYi5zZXJ2aWNlJztcclxuXHJcbi8vIFR5cGVzICYgVG9rZW5zXHJcbmV4cG9ydCB7XHJcbiAgVWlCcmVhZGNydW1iSXRlbSxcclxuICBVaUJyZWFkY3J1bWJDb25maWcsXHJcbiAgVWlMYWJlbFJlc29sdmVyRm4sXHJcbiAgVUlfQlJFQURDUlVNQl9MQUJFTF9SRVNPTFZFUixcclxufSBmcm9tICcuL3BhZ2UtaGVhZGVyLnR5cGVzJztcclxuIl19