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

package/esm2022/base-layout/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":"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","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/base-layout/lib/components/page-header/page-header.component.mjs

@@ -0,0 +1,243 @@
+import { ChangeDetectorRef, Component, DestroyRef, inject, Input, ChangeDetectionStrategy, ViewEncapsulation, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, NavigationEnd, Router, RouterLink } from '@angular/router';
+import { Title } from '@angular/platform-browser';
+import { filter } from 'rxjs/operators';
+import { LucideAngularModule } from 'lucide-angular';
+import { UiBreadcrumbService } from './breadcrumb.service';
+import * as i0 from "@angular/core";
+import * as i1 from "lucide-angular";
+/**
+ * Page header component that renders a breadcrumb navigation trail
+ * and a page title. Integrates with `UiBreadcrumbService` to
+ * automatically derive breadcrumbs from Angular route configuration.
+ *
+ * The breadcrumb trail is generated from route `data` properties:
+ * - `data.id` — unique route identifier
+ * - `data.title` — display label
+ * - `data.breadcrumbs` — ordered array of parent route IDs
+ *
+ * @selector ui-page-header
+ *
+ * @example
+ * ```html
+ * <!-- Auto breadcrumbs from route data -->
+ * <ui-page-header />
+ *
+ * <!-- With explicit title override -->
+ * <ui-page-header title="Custom Title" />
+ *
+ * <!-- With document title update -->
+ * <ui-page-header [updateDocumentTitle]="true" titleSuffix=" | My App" />
+ * ```
+ */
+export class UiPageHeaderComponent {
+    constructor() {
+        /** Override the auto-detected page title. When empty, title is derived from the last breadcrumb. */
+        this.title = '';
+        /** Route path for the Home breadcrumb link. */
+        this.homeRoute = '/';
+        /** Whether to display the Home link at the start of the trail. */
+        this.showHome = true;
+        /** When `true`, updates `document.title` on each navigation. */
+        this.updateDocumentTitle = false;
+        /** Suffix appended to `document.title` (e.g. `' | My App'`). Only used when `updateDocumentTitle` is `true`. */
+        this.titleSuffix = '';
+        /** @internal */
+        this.breadcrumbs = [];
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+        this.titleService = inject(Title);
+        this.breadcrumbService = inject(UiBreadcrumbService);
+        this.destroyRef = inject(DestroyRef);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    /** Resolved page title: explicit `title` input wins, otherwise last breadcrumb label. */
+    get displayTitle() {
+        if (this.title)
+            return this.title;
+        if (this.breadcrumbs.length > 0) {
+            return this.breadcrumbs[this.breadcrumbs.length - 1].label;
+        }
+        return '';
+    }
+    ngOnInit() {
+        this.refresh();
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => this.refresh());
+    }
+    /**
+     * Navigates to the previous breadcrumb (parent route).
+     * @param fallbackUrl - URL to navigate to when no parent exists (default: homeRoute).
+     */
+    navigateBack(fallbackUrl) {
+        this.breadcrumbService.navigateBack(fallbackUrl ?? this.homeRoute);
+    }
+    /** @internal */
+    refresh() {
+        this.breadcrumbs = this.breadcrumbService.getBreadcrumbsForRoute(this.activatedRoute);
+        if (this.updateDocumentTitle) {
+            const title = this.displayTitle;
+            if (title) {
+                this.titleService.setTitle(`${title}${this.titleSuffix}`);
+            }
+        }
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiPageHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiPageHeaderComponent, isStandalone: true, selector: "ui-page-header", inputs: { title: "title", homeRoute: "homeRoute", showHome: "showHome", updateDocumentTitle: "updateDocumentTitle", titleSuffix: "titleSuffix" }, host: { classAttribute: "ui-page-header-host" }, ngImport: i0, template: `
+    <header class="ui-page-header">
+      <nav aria-label="Breadcrumb" class="ui-page-header__nav">
+        <ol
+          class="ui-page-header__breadcrumb"
+          itemscope
+          itemtype="https://schema.org/BreadcrumbList"
+        >
+          @if (showHome) {
+            <li
+              class="ui-page-header__item"
+              itemprop="itemListElement"
+              itemscope
+              itemtype="https://schema.org/ListItem"
+            >
+              <a
+                itemprop="item"
+                [routerLink]="homeRoute"
+                class="ui-page-header__link"
+                aria-label="Home"
+              >
+                <lucide-icon name="home" [size]="14" aria-hidden="true" />
+                <span itemprop="name" class="ui-page-header__text">Home</span>
+              </a>
+              <meta itemprop="position" content="1" />
+              <span class="ui-page-header__separator" aria-hidden="true">
+                <lucide-icon name="chevron-right" [size]="14" />
+              </span>
+            </li>
+          }
+          @for (crumb of breadcrumbs; track crumb.url; let i = $index) {
+            <li
+              class="ui-page-header__item"
+              [class.ui-page-header__item--current]="crumb.isLast"
+              itemprop="itemListElement"
+              itemscope
+              itemtype="https://schema.org/ListItem"
+            >
+              @if (!crumb.isLast) {
+                <a
+                  itemprop="item"
+                  [routerLink]="crumb.url"
+                  class="ui-page-header__link"
+                >
+                  <span itemprop="name" class="ui-page-header__text">{{ crumb.label }}</span>
+                </a>
+                <span class="ui-page-header__separator" aria-hidden="true">
+                  <lucide-icon name="chevron-right" [size]="14" />
+                </span>
+              } @else {
+                <span
+                  itemprop="name"
+                  class="ui-page-header__text ui-page-header__text--current"
+                  aria-current="page"
+                >
+                  {{ crumb.label }}
+                </span>
+              }
+              <meta itemprop="position" [attr.content]="showHome ? i + 2 : i + 1" />
+            </li>
+          }
+        </ol>
+      </nav>
+
+      <h1 class="ui-page-header__title" id="page-title">
+        {{ displayTitle }}
+      </h1>
+    </header>
+  `, isInline: true, styles: [".ui-page-header-host{display:block}.ui-page-header{margin-bottom:var(--ui-spacing-5)}.ui-page-header__nav{margin-bottom:var(--ui-spacing-2)}.ui-page-header__breadcrumb{display:flex;flex-wrap:wrap;align-items:center;list-style:none;margin:0;padding:0;font-family:var(--ui-font-family);font-size:var(--ui-font-size-sm);line-height:var(--ui-line-height-normal);gap:var(--ui-spacing-1)}.ui-page-header__item{display:inline-flex;align-items:center;gap:var(--ui-spacing-1)}a.ui-page-header__link lucide-icon{transform:translateY(2px)!important}span.ui-page-header__separator lucide-icon{transform:translateY(3px)!important}.ui-page-header__link{display:inline-flex;align-items:center;gap:4px;text-decoration:none;color:var(--ui-color-primary);border-radius:var(--ui-radius-sm);padding:2px 4px;margin:-2px -4px;transition:color var(--ui-transition-fast),background-color var(--ui-transition-fast)}.ui-page-header__link:hover{color:var(--ui-color-primary-hover);text-decoration:underline}.ui-page-header__link:focus{outline:none}.ui-page-header__link:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-page-header__text{white-space:nowrap}.ui-page-header__text--current{font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text)}.ui-page-header__separator{display:inline-flex;align-items:center;color:var(--ui-color-text-muted);flex-shrink:0}.ui-page-header__title{margin:0;font-family:var(--ui-font-family);font-size:var(--ui-font-size-2xl);font-weight:var(--ui-font-weight-bold);color:var(--ui-color-text);line-height:var(--ui-line-height-tight)}.ui-page-header__title:focus{outline:none}@media (min-width: 640px){.ui-page-header__title{font-size:var(--ui-font-size-xl)}.ui-page-header__breadcrumb{font-size:var(--ui-font-size-xs)}}\n"], dependencies: [{ kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i1.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiPageHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-page-header', standalone: true, imports: [RouterLink, LucideAngularModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'ui-page-header-host',
+                    }, template: `
+    <header class="ui-page-header">
+      <nav aria-label="Breadcrumb" class="ui-page-header__nav">
+        <ol
+          class="ui-page-header__breadcrumb"
+          itemscope
+          itemtype="https://schema.org/BreadcrumbList"
+        >
+          @if (showHome) {
+            <li
+              class="ui-page-header__item"
+              itemprop="itemListElement"
+              itemscope
+              itemtype="https://schema.org/ListItem"
+            >
+              <a
+                itemprop="item"
+                [routerLink]="homeRoute"
+                class="ui-page-header__link"
+                aria-label="Home"
+              >
+                <lucide-icon name="home" [size]="14" aria-hidden="true" />
+                <span itemprop="name" class="ui-page-header__text">Home</span>
+              </a>
+              <meta itemprop="position" content="1" />
+              <span class="ui-page-header__separator" aria-hidden="true">
+                <lucide-icon name="chevron-right" [size]="14" />
+              </span>
+            </li>
+          }
+          @for (crumb of breadcrumbs; track crumb.url; let i = $index) {
+            <li
+              class="ui-page-header__item"
+              [class.ui-page-header__item--current]="crumb.isLast"
+              itemprop="itemListElement"
+              itemscope
+              itemtype="https://schema.org/ListItem"
+            >
+              @if (!crumb.isLast) {
+                <a
+                  itemprop="item"
+                  [routerLink]="crumb.url"
+                  class="ui-page-header__link"
+                >
+                  <span itemprop="name" class="ui-page-header__text">{{ crumb.label }}</span>
+                </a>
+                <span class="ui-page-header__separator" aria-hidden="true">
+                  <lucide-icon name="chevron-right" [size]="14" />
+                </span>
+              } @else {
+                <span
+                  itemprop="name"
+                  class="ui-page-header__text ui-page-header__text--current"
+                  aria-current="page"
+                >
+                  {{ crumb.label }}
+                </span>
+              }
+              <meta itemprop="position" [attr.content]="showHome ? i + 2 : i + 1" />
+            </li>
+          }
+        </ol>
+      </nav>
+
+      <h1 class="ui-page-header__title" id="page-title">
+        {{ displayTitle }}
+      </h1>
+    </header>
+  `, styles: [".ui-page-header-host{display:block}.ui-page-header{margin-bottom:var(--ui-spacing-5)}.ui-page-header__nav{margin-bottom:var(--ui-spacing-2)}.ui-page-header__breadcrumb{display:flex;flex-wrap:wrap;align-items:center;list-style:none;margin:0;padding:0;font-family:var(--ui-font-family);font-size:var(--ui-font-size-sm);line-height:var(--ui-line-height-normal);gap:var(--ui-spacing-1)}.ui-page-header__item{display:inline-flex;align-items:center;gap:var(--ui-spacing-1)}a.ui-page-header__link lucide-icon{transform:translateY(2px)!important}span.ui-page-header__separator lucide-icon{transform:translateY(3px)!important}.ui-page-header__link{display:inline-flex;align-items:center;gap:4px;text-decoration:none;color:var(--ui-color-primary);border-radius:var(--ui-radius-sm);padding:2px 4px;margin:-2px -4px;transition:color var(--ui-transition-fast),background-color var(--ui-transition-fast)}.ui-page-header__link:hover{color:var(--ui-color-primary-hover);text-decoration:underline}.ui-page-header__link:focus{outline:none}.ui-page-header__link:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-page-header__text{white-space:nowrap}.ui-page-header__text--current{font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text)}.ui-page-header__separator{display:inline-flex;align-items:center;color:var(--ui-color-text-muted);flex-shrink:0}.ui-page-header__title{margin:0;font-family:var(--ui-font-family);font-size:var(--ui-font-size-2xl);font-weight:var(--ui-font-weight-bold);color:var(--ui-color-text);line-height:var(--ui-line-height-tight)}.ui-page-header__title:focus{outline:none}@media (min-width: 640px){.ui-page-header__title{font-size:var(--ui-font-size-xl)}.ui-page-header__breadcrumb{font-size:var(--ui-font-size-xs)}}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], homeRoute: [{
+                type: Input
+            }], showHome: [{
+                type: Input
+            }], updateDocumentTitle: [{
+                type: Input
+            }], titleSuffix: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-header.component.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/page-header/page-header.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  DestroyRef,\r\n  inject,\r\n  Input,\r\n  OnInit,\r\n  ChangeDetectionStrategy,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\r\nimport { ActivatedRoute, NavigationEnd, Router, RouterLink } from '@angular/router';\r\nimport { Title } from '@angular/platform-browser';\r\nimport { filter } from 'rxjs/operators';\r\nimport { LucideAngularModule } from 'lucide-angular';\r\nimport { UiBreadcrumbService } from './breadcrumb.service';\r\nimport { UiBreadcrumbItem } from './page-header.types';\r\n\r\n/**\r\n * Page header component that renders a breadcrumb navigation trail\r\n * and a page title. Integrates with `UiBreadcrumbService` to\r\n * automatically derive breadcrumbs from Angular route configuration.\r\n *\r\n * The breadcrumb trail is generated from route `data` properties:\r\n * - `data.id` — unique route identifier\r\n * - `data.title` — display label\r\n * - `data.breadcrumbs` — ordered array of parent route IDs\r\n *\r\n * @selector ui-page-header\r\n *\r\n * @example\r\n * ```html\r\n * <!-- Auto breadcrumbs from route data -->\r\n * <ui-page-header />\r\n *\r\n * <!-- With explicit title override -->\r\n * <ui-page-header title=\"Custom Title\" />\r\n *\r\n * <!-- With document title update -->\r\n * <ui-page-header [updateDocumentTitle]=\"true\" titleSuffix=\" | My App\" />\r\n * ```\r\n */\r\n@Component({\r\n  selector: 'ui-page-header',\r\n  standalone: true,\r\n  imports: [RouterLink, LucideAngularModule],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n  host: {\r\n    class: 'ui-page-header-host',\r\n  },\r\n  template: `\r\n    <header class=\"ui-page-header\">\r\n      <nav aria-label=\"Breadcrumb\" class=\"ui-page-header__nav\">\r\n        <ol\r\n          class=\"ui-page-header__breadcrumb\"\r\n          itemscope\r\n          itemtype=\"https://schema.org/BreadcrumbList\"\r\n        >\r\n          @if (showHome) {\r\n            <li\r\n              class=\"ui-page-header__item\"\r\n              itemprop=\"itemListElement\"\r\n              itemscope\r\n              itemtype=\"https://schema.org/ListItem\"\r\n            >\r\n              <a\r\n                itemprop=\"item\"\r\n                [routerLink]=\"homeRoute\"\r\n                class=\"ui-page-header__link\"\r\n                aria-label=\"Home\"\r\n              >\r\n                <lucide-icon name=\"home\" [size]=\"14\" aria-hidden=\"true\" />\r\n                <span itemprop=\"name\" class=\"ui-page-header__text\">Home</span>\r\n              </a>\r\n              <meta itemprop=\"position\" content=\"1\" />\r\n              <span class=\"ui-page-header__separator\" aria-hidden=\"true\">\r\n                <lucide-icon name=\"chevron-right\" [size]=\"14\" />\r\n              </span>\r\n            </li>\r\n          }\r\n          @for (crumb of breadcrumbs; track crumb.url; let i = $index) {\r\n            <li\r\n              class=\"ui-page-header__item\"\r\n              [class.ui-page-header__item--current]=\"crumb.isLast\"\r\n              itemprop=\"itemListElement\"\r\n              itemscope\r\n              itemtype=\"https://schema.org/ListItem\"\r\n            >\r\n              @if (!crumb.isLast) {\r\n                <a\r\n                  itemprop=\"item\"\r\n                  [routerLink]=\"crumb.url\"\r\n                  class=\"ui-page-header__link\"\r\n                >\r\n                  <span itemprop=\"name\" class=\"ui-page-header__text\">{{ crumb.label }}</span>\r\n                </a>\r\n                <span class=\"ui-page-header__separator\" aria-hidden=\"true\">\r\n                  <lucide-icon name=\"chevron-right\" [size]=\"14\" />\r\n                </span>\r\n              } @else {\r\n                <span\r\n                  itemprop=\"name\"\r\n                  class=\"ui-page-header__text ui-page-header__text--current\"\r\n                  aria-current=\"page\"\r\n                >\r\n                  {{ crumb.label }}\r\n                </span>\r\n              }\r\n              <meta itemprop=\"position\" [attr.content]=\"showHome ? i + 2 : i + 1\" />\r\n            </li>\r\n          }\r\n        </ol>\r\n      </nav>\r\n\r\n      <h1 class=\"ui-page-header__title\" id=\"page-title\">\r\n        {{ displayTitle }}\r\n      </h1>\r\n    </header>\r\n  `,\r\n  styleUrl: './page-header.component.scss',\r\n})\r\nexport class UiPageHeaderComponent implements OnInit {\r\n  /** Override the auto-detected page title. When empty, title is derived from the last breadcrumb. */\r\n  @Input() title = '';\r\n\r\n  /** Route path for the Home breadcrumb link. */\r\n  @Input() homeRoute = '/';\r\n\r\n  /** Whether to display the Home link at the start of the trail. */\r\n  @Input() showHome = true;\r\n\r\n  /** When `true`, updates `document.title` on each navigation. */\r\n  @Input() updateDocumentTitle = false;\r\n\r\n  /** Suffix appended to `document.title` (e.g. `' | My App'`). Only used when `updateDocumentTitle` is `true`. */\r\n  @Input() titleSuffix = '';\r\n\r\n  /** @internal */\r\n  breadcrumbs: UiBreadcrumbItem[] = [];\r\n\r\n  private readonly router = inject(Router);\r\n  private readonly activatedRoute = inject(ActivatedRoute);\r\n  private readonly titleService = inject(Title);\r\n  private readonly breadcrumbService = inject(UiBreadcrumbService);\r\n  private readonly destroyRef = inject(DestroyRef);\r\n  private readonly cdr = inject(ChangeDetectorRef);\r\n\r\n  /** Resolved page title: explicit `title` input wins, otherwise last breadcrumb label. */\r\n  get displayTitle(): string {\r\n    if (this.title) return this.title;\r\n    if (this.breadcrumbs.length > 0) {\r\n      return this.breadcrumbs[this.breadcrumbs.length - 1].label;\r\n    }\r\n    return '';\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.refresh();\r\n\r\n    this.router.events\r\n      .pipe(\r\n        filter((event) => event instanceof NavigationEnd),\r\n        takeUntilDestroyed(this.destroyRef),\r\n      )\r\n      .subscribe(() => this.refresh());\r\n  }\r\n\r\n  /**\r\n   * Navigates to the previous breadcrumb (parent route).\r\n   * @param fallbackUrl - URL to navigate to when no parent exists (default: homeRoute).\r\n   */\r\n  navigateBack(fallbackUrl?: string): void {\r\n    this.breadcrumbService.navigateBack(fallbackUrl ?? this.homeRoute);\r\n  }\r\n\r\n  /** @internal */\r\n  private refresh(): void {\r\n    this.breadcrumbs = this.breadcrumbService.getBreadcrumbsForRoute(this.activatedRoute);\r\n    if (this.updateDocumentTitle) {\r\n      const title = this.displayTitle;\r\n      if (title) {\r\n        this.titleService.setTitle(`${title}${this.titleSuffix}`);\r\n      }\r\n    }\r\n    this.cdr.markForCheck();\r\n  }\r\n}\r\n"]}

package/esm2022/base-layout/lib/components/page-header/page-header.types.mjs

@@ -0,0 +1,21 @@
+/**
+ * @module ng-ui-system/page-header
+ * Types and interfaces for UiPageHeader and UiBreadcrumbService.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for providing a custom label resolver to UiBreadcrumbService.
+ *
+ * When not provided, parameters are displayed as-is (identity function).
+ *
+ * @example
+ * ```typescript
+ * // In your app.config.ts or module providers:
+ * { provide: UI_BREADCRUMB_LABEL_RESOLVER, useValue: myLabelResolver }
+ * ```
+ */
+export const UI_BREADCRUMB_LABEL_RESOLVER = new InjectionToken('UI_BREADCRUMB_LABEL_RESOLVER', {
+    providedIn: 'root',
+    factory: () => (_name, value) => value,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/base-layout/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/blackbox/entry-blackbox.mjs

@@ -0,0 +1,5 @@
+/**
+ * Bootstrap del secondary entry `@gnggln/ng-ui-system/blackbox`. BlackBox observability.
+ */
+export * from './lib/components/blackbox/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cnktYmxhY2tib3guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2VudHJ5LWJsYWNrYm94LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQm9vdHN0cmFwIGRlbCBzZWNvbmRhcnkgZW50cnkgYEBnbmdnbG4vbmctdWktc3lzdGVtL2JsYWNrYm94YC4gQmxhY2tCb3ggb2JzZXJ2YWJpbGl0eS5cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ibGFja2JveC9pbmRleCc7XG5cbiJdfQ==

package/esm2022/blackbox/gnggln-ng-ui-system-blackbox.mjs

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