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

package/esm2022/base-layout/gnggln-ng-ui-system-base-layout.mjs

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

package/esm2022/base-layout/lib/components/base-layout/base-layout.component.mjs

@@ -0,0 +1,272 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, Input, inject, signal, ViewEncapsulation, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
+import { debounceTime, filter } from 'rxjs/operators';
+import { UiButtonAreaComponent } from '../button/button-area.component';
+import { UiBreadcrumbService } from '../page-header/breadcrumb.service';
+import { UiPageHeaderComponent } from '../page-header/page-header.component';
+import * as i0 from "@angular/core";
+/**
+ * Full-page layout component that combines a page header (breadcrumbs + title),
+ * a main content area via `<ng-content>`, and a sticky footer action bar
+ * powered by `UiButtonAreaComponent`.
+ *
+ * Optionally renders an automatic "back" button in the footer, derived from
+ * the breadcrumb trail (navigates to the parent breadcrumb).
+ *
+ * ### Route `data`
+ *
+ * Sulla rotta attiva (foglia) puoi impostare:
+ *
+ * - `breadcrumbOff: true` — nasconde `ui-page-header`
+ * - `footerNavOff: true` — nasconde `ui-base-layout__footer`
+ * - `id: string` — valorizza `data-route-id` sul contenitore `.ui-base-layout`
+ *
+ * @selector ui-base-layout
+ *
+ * @example
+ * ```html
+ * <ui-base-layout [actions]="pageActions" footerAlign="end">
+ *   <p>Your page content here</p>
+ * </ui-base-layout>
+ * ```
+ *
+ * @example
+ * ```html
+ * <!-- With back button and custom title -->
+ * <ui-base-layout
+ *   title="Dettaglio utente"
+ *   [showBackButton]="true"
+ *   [actions]="[
+ *     { id: 'save', label: 'Salva', variant: 'primary', icon: 'save', action: save },
+ *   ]"
+ * >
+ *   <app-user-detail />
+ * </ui-base-layout>
+ * ```
+ */
+export class UiBaseLayoutComponent {
+    constructor() {
+        /** Whether to display the page header (breadcrumbs + title). */
+        this.showHeader = true;
+        /** Override the auto-detected page title. Passed through to `ui-page-header`. */
+        this.title = '';
+        /** Route path for the Home breadcrumb link. */
+        this.homeRoute = '/';
+        /** Whether to display the Home link in the breadcrumb trail. */
+        this.showHome = true;
+        /** When `true`, updates `document.title` on navigation. */
+        this.updateDocumentTitle = false;
+        /** Suffix appended to `document.title`. */
+        this.titleSuffix = '';
+        /** Whether to show an automatic "back" button based on breadcrumbs. */
+        this.showBackButton = true;
+        /** Configuration overrides for the automatic back button. */
+        this.backButtonConfig = {};
+        /** Array of button descriptors for the footer action area. */
+        this.actions = [];
+        /** Horizontal alignment of the footer button area. */
+        this.footerAlign = 'start';
+        /** Gap size between footer buttons. */
+        this.footerGap = 'sm';
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+        this.breadcrumbService = inject(UiBreadcrumbService);
+        this.destroyRef = inject(DestroyRef);
+        /**
+         * Flag derivati dalla catena attiva (`breadcrumbOff`, `footerNavOff`, `id`).
+         * Aggiornati a ogni `NavigationEnd`.
+         */
+        this.routeSnapshotFlags = signal({
+            breadcrumbOff: false,
+            footerNavOff: false,
+            routeId: null,
+        });
+        /** Header visibile se abilitato da input e non disattivato da `data.breadcrumbOff`. */
+        this.effectiveShowHeader = () => this.showHeader && !this.routeSnapshotFlags().breadcrumbOff;
+        /** Footer azioni visibile se ci sono azioni visibili e non disattivato da `data.footerNavOff`. */
+        this.effectiveShowFooterNav = () => !this.routeSnapshotFlags().footerNavOff && this.hasVisibleActions;
+    }
+    /**
+     * Merged action list (back button + consumer actions).
+     * Computed on every change-detection check so it stays in sync
+     * with both navigation state (breadcrumbs) and input changes.
+     */
+    get mergedActions() {
+        const result = [];
+        if (this.showBackButton) {
+            result.push({
+                id: '__ui-back',
+                label: this.backButtonConfig.label ?? 'Indietro',
+                icon: this.backButtonConfig.icon ?? 'arrow-left',
+                iconPosition: 'leading',
+                variant: this.backButtonConfig.variant ?? 'outline',
+                hidden: this.shouldHideBackButton(),
+                action: () => this.navigateBack(),
+            });
+        }
+        result.push(...this.actions);
+        return result;
+    }
+    /** Whether the footer should render (at least one non-hidden action exists). */
+    get hasVisibleActions() {
+        return this.mergedActions.some((a) => !a.hidden);
+    }
+    ngOnInit() {
+        this.syncFromActivatedRoute();
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), debounceTime(50), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => this.syncFromActivatedRoute());
+    }
+    /** @internal Allinea breadcrumb service e flag layout alla rotta corrente. */
+    syncFromActivatedRoute() {
+        this.refreshRouteSnapshotFlags();
+        this.breadcrumbService.getBreadcrumbsForRoute(this.activatedRoute);
+    }
+    /** @internal Legge `breadcrumbOff`, `footerNavOff`, `id` dalla catena `pathFromRoot` / foglia. */
+    refreshRouteSnapshotFlags() {
+        const deepest = this.deepestChildRoute(this.activatedRoute);
+        let breadcrumbOff = false;
+        let footerNavOff = false;
+        for (const seg of deepest.pathFromRoot) {
+            const d = seg.snapshot.data;
+            if (!d)
+                continue;
+            // biome-ignore lint/complexity/useLiteralKeys: chiavi documentate in UiBaseLayoutRouteData
+            if (d['breadcrumbOff'] === true)
+                breadcrumbOff = true;
+            // biome-ignore lint/complexity/useLiteralKeys: chiavi documentate in UiBaseLayoutRouteData
+            if (d['footerNavOff'] === true)
+                footerNavOff = true;
+        }
+        let routeId = null;
+        let cursor = deepest;
+        while (cursor) {
+            const raw = cursor.snapshot.data?.['id'];
+            if (typeof raw === 'string' && raw.length > 0) {
+                routeId = raw;
+                break;
+            }
+            cursor = cursor.parent;
+        }
+        this.routeSnapshotFlags.set({ breadcrumbOff, footerNavOff, routeId });
+    }
+    /** @internal Percorre fino al `ActivatedRoute` foglia sotto il punto di iniezione. */
+    deepestChildRoute(route) {
+        let deepest = route;
+        while (deepest.firstChild) {
+            deepest = deepest.firstChild;
+        }
+        return deepest;
+    }
+    /** @internal Determina se il back button deve essere nascosto per la rotta corrente. */
+    shouldHideBackButton() {
+        const currentPath = this.router.url.split('?')[0].split('#')[0];
+        if (currentPath === this.homeRoute) {
+            return true;
+        }
+        const deepestRoute = this.deepestChildRoute(this.activatedRoute);
+        // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+        if (deepestRoute.snapshot.data?.['hideBackButton'] === true) {
+            return true;
+        }
+        return false;
+    }
+    /** @internal Naviga al breadcrumb genitore o esegue il fallback alla home route. */
+    navigateBack() {
+        this.breadcrumbService.navigateBack(this.homeRoute);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBaseLayoutComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiBaseLayoutComponent, isStandalone: true, selector: "ui-base-layout", inputs: { showHeader: "showHeader", title: "title", homeRoute: "homeRoute", showHome: "showHome", updateDocumentTitle: "updateDocumentTitle", titleSuffix: "titleSuffix", showBackButton: "showBackButton", backButtonConfig: "backButtonConfig", actions: "actions", footerAlign: "footerAlign", footerGap: "footerGap" }, host: { classAttribute: "ui-base-layout-host" }, ngImport: i0, template: `
+    <div class="ui-base-layout" [attr.data-route-id]="routeSnapshotFlags().routeId">
+      @if (effectiveShowHeader()) {
+        <ui-page-header
+          [title]="title"
+          [homeRoute]="homeRoute"
+          [showHome]="showHome"
+          [updateDocumentTitle]="updateDocumentTitle"
+          [titleSuffix]="titleSuffix"
+        />
+      }
+
+      <main class="ui-base-layout__content">
+        <ng-content />
+      </main>
+
+      @if (effectiveShowFooterNav()) {
+        <aside
+          class="ui-base-layout__footer"
+          aria-label="Page actions"
+        >
+          <ui-button-area
+            [buttons]="mergedActions"
+            [align]="footerAlign"
+            [gap]="footerGap"
+            [stackOnMobile]="true"
+            ariaLabel="Page actions"
+          />
+        </aside>
+      }
+    </div>
+  `, isInline: true, styles: [".ui-base-layout-host{display:block;min-height:100%}.ui-base-layout{display:flex;flex-direction:column;min-height:100%;font-family:var(--ui-font-family);padding:var(--ui-spacing-6)}.ui-base-layout__content{flex:1 1 auto}.ui-base-layout__footer{position:sticky;bottom:0;z-index:var(--ui-z-sticky, 100);padding:var(--ui-spacing-4) 0;margin-top:var(--ui-spacing-6);background:var(--ui-color-surface);border-top:1px solid var(--ui-color-border)}@media (min-width: 640px){.ui-base-layout__footer{padding:var(--ui-spacing-3) 0}}\n"], dependencies: [{ kind: "component", type: UiPageHeaderComponent, selector: "ui-page-header", inputs: ["title", "homeRoute", "showHome", "updateDocumentTitle", "titleSuffix"] }, { kind: "component", type: UiButtonAreaComponent, selector: "ui-button-area", inputs: ["buttons", "align", "ariaLabel", "gap", "stackOnMobile", "disableWhileLoading", "loadingIds"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBaseLayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-base-layout', standalone: true, imports: [UiPageHeaderComponent, UiButtonAreaComponent], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'ui-base-layout-host',
+                    }, template: `
+    <div class="ui-base-layout" [attr.data-route-id]="routeSnapshotFlags().routeId">
+      @if (effectiveShowHeader()) {
+        <ui-page-header
+          [title]="title"
+          [homeRoute]="homeRoute"
+          [showHome]="showHome"
+          [updateDocumentTitle]="updateDocumentTitle"
+          [titleSuffix]="titleSuffix"
+        />
+      }
+
+      <main class="ui-base-layout__content">
+        <ng-content />
+      </main>
+
+      @if (effectiveShowFooterNav()) {
+        <aside
+          class="ui-base-layout__footer"
+          aria-label="Page actions"
+        >
+          <ui-button-area
+            [buttons]="mergedActions"
+            [align]="footerAlign"
+            [gap]="footerGap"
+            [stackOnMobile]="true"
+            ariaLabel="Page actions"
+          />
+        </aside>
+      }
+    </div>
+  `, styles: [".ui-base-layout-host{display:block;min-height:100%}.ui-base-layout{display:flex;flex-direction:column;min-height:100%;font-family:var(--ui-font-family);padding:var(--ui-spacing-6)}.ui-base-layout__content{flex:1 1 auto}.ui-base-layout__footer{position:sticky;bottom:0;z-index:var(--ui-z-sticky, 100);padding:var(--ui-spacing-4) 0;margin-top:var(--ui-spacing-6);background:var(--ui-color-surface);border-top:1px solid var(--ui-color-border)}@media (min-width: 640px){.ui-base-layout__footer{padding:var(--ui-spacing-3) 0}}\n"] }]
+        }], propDecorators: { showHeader: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], homeRoute: [{
+                type: Input
+            }], showHome: [{
+                type: Input
+            }], updateDocumentTitle: [{
+                type: Input
+            }], titleSuffix: [{
+                type: Input
+            }], showBackButton: [{
+                type: Input
+            }], backButtonConfig: [{
+                type: Input
+            }], actions: [{
+                type: Input
+            }], footerAlign: [{
+                type: Input
+            }], footerGap: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-layout.component.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/base-layout/base-layout.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  Component,\r\n  DestroyRef,\r\n  Input,\r\n  inject,\r\n  signal,\r\n  type OnInit,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\r\n\r\nimport { ActivatedRoute, NavigationEnd, Router } from '@angular/router';\r\nimport { debounceTime, filter } from 'rxjs/operators';\r\nimport type { UiButtonAreaAlign, UiButtonDescriptor } from '../button/button.types';\r\nimport { UiButtonAreaComponent } from '../button/button-area.component';\r\nimport { UiBreadcrumbService } from '../page-header/breadcrumb.service';\r\nimport { UiPageHeaderComponent } from '../page-header/page-header.component';\r\nimport type { UiBackButtonConfig } from './base-layout.types';\r\n\r\n/** Stato letto dalla rotta foglia per header/footer opzionali e `data-route-id`. */\r\ninterface UiBaseLayoutRouteSnapshotFlags {\r\n  breadcrumbOff: boolean;\r\n  footerNavOff: boolean;\r\n  routeId: string | null;\r\n}\r\n\r\n/**\r\n * Full-page layout component that combines a page header (breadcrumbs + title),\r\n * a main content area via `<ng-content>`, and a sticky footer action bar\r\n * powered by `UiButtonAreaComponent`.\r\n *\r\n * Optionally renders an automatic \"back\" button in the footer, derived from\r\n * the breadcrumb trail (navigates to the parent breadcrumb).\r\n *\r\n * ### Route `data`\r\n *\r\n * Sulla rotta attiva (foglia) puoi impostare:\r\n *\r\n * - `breadcrumbOff: true` — nasconde `ui-page-header`\r\n * - `footerNavOff: true` — nasconde `ui-base-layout__footer`\r\n * - `id: string` — valorizza `data-route-id` sul contenitore `.ui-base-layout`\r\n *\r\n * @selector ui-base-layout\r\n *\r\n * @example\r\n * ```html\r\n * <ui-base-layout [actions]=\"pageActions\" footerAlign=\"end\">\r\n *   <p>Your page content here</p>\r\n * </ui-base-layout>\r\n * ```\r\n *\r\n * @example\r\n * ```html\r\n * <!-- With back button and custom title -->\r\n * <ui-base-layout\r\n *   title=\"Dettaglio utente\"\r\n *   [showBackButton]=\"true\"\r\n *   [actions]=\"[\r\n *     { id: 'save', label: 'Salva', variant: 'primary', icon: 'save', action: save },\r\n *   ]\"\r\n * >\r\n *   <app-user-detail />\r\n * </ui-base-layout>\r\n * ```\r\n */\r\n@Component({\r\n  selector: 'ui-base-layout',\r\n  standalone: true,\r\n  imports: [UiPageHeaderComponent, UiButtonAreaComponent],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n  host: {\r\n    class: 'ui-base-layout-host',\r\n  },\r\n  template: `\r\n    <div class=\"ui-base-layout\" [attr.data-route-id]=\"routeSnapshotFlags().routeId\">\r\n      @if (effectiveShowHeader()) {\r\n        <ui-page-header\r\n          [title]=\"title\"\r\n          [homeRoute]=\"homeRoute\"\r\n          [showHome]=\"showHome\"\r\n          [updateDocumentTitle]=\"updateDocumentTitle\"\r\n          [titleSuffix]=\"titleSuffix\"\r\n        />\r\n      }\r\n\r\n      <main class=\"ui-base-layout__content\">\r\n        <ng-content />\r\n      </main>\r\n\r\n      @if (effectiveShowFooterNav()) {\r\n        <aside\r\n          class=\"ui-base-layout__footer\"\r\n          aria-label=\"Page actions\"\r\n        >\r\n          <ui-button-area\r\n            [buttons]=\"mergedActions\"\r\n            [align]=\"footerAlign\"\r\n            [gap]=\"footerGap\"\r\n            [stackOnMobile]=\"true\"\r\n            ariaLabel=\"Page actions\"\r\n          />\r\n        </aside>\r\n      }\r\n    </div>\r\n  `,\r\n  styleUrl: './base-layout.component.scss',\r\n})\r\nexport class UiBaseLayoutComponent implements OnInit {\r\n  /** Whether to display the page header (breadcrumbs + title). */\r\n  @Input() showHeader = true;\r\n\r\n  /** Override the auto-detected page title. Passed through to `ui-page-header`. */\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 in the breadcrumb trail. */\r\n  @Input() showHome = true;\r\n\r\n  /** When `true`, updates `document.title` on navigation. */\r\n  @Input() updateDocumentTitle = false;\r\n\r\n  /** Suffix appended to `document.title`. */\r\n  @Input() titleSuffix = '';\r\n\r\n  /** Whether to show an automatic \"back\" button based on breadcrumbs. */\r\n  @Input() showBackButton = true;\r\n\r\n  /** Configuration overrides for the automatic back button. */\r\n  @Input() backButtonConfig: UiBackButtonConfig = {};\r\n\r\n  /** Array of button descriptors for the footer action area. */\r\n  @Input() actions: UiButtonDescriptor[] = [];\r\n\r\n  /** Horizontal alignment of the footer button area. */\r\n  @Input() footerAlign: UiButtonAreaAlign = 'start';\r\n\r\n  /** Gap size between footer buttons. */\r\n  @Input() footerGap: 'xs' | 'sm' | 'md' | 'lg' | 'xl' = 'sm';\r\n\r\n  private readonly router = inject(Router);\r\n\r\n  private readonly activatedRoute = inject(ActivatedRoute);\r\n  private readonly breadcrumbService = inject(UiBreadcrumbService);\r\n  private readonly destroyRef = inject(DestroyRef);\r\n\r\n  /**\r\n   * Flag derivati dalla catena attiva (`breadcrumbOff`, `footerNavOff`, `id`).\r\n   * Aggiornati a ogni `NavigationEnd`.\r\n   */\r\n  protected readonly routeSnapshotFlags = signal<UiBaseLayoutRouteSnapshotFlags>({\r\n    breadcrumbOff: false,\r\n    footerNavOff: false,\r\n    routeId: null,\r\n  });\r\n\r\n  /** Header visibile se abilitato da input e non disattivato da `data.breadcrumbOff`. */\r\n  protected readonly effectiveShowHeader = () =>\r\n    this.showHeader && !this.routeSnapshotFlags().breadcrumbOff;\r\n\r\n  /** Footer azioni visibile se ci sono azioni visibili e non disattivato da `data.footerNavOff`. */\r\n  protected readonly effectiveShowFooterNav = () =>\r\n    !this.routeSnapshotFlags().footerNavOff && this.hasVisibleActions;\r\n\r\n  /**\r\n   * Merged action list (back button + consumer actions).\r\n   * Computed on every change-detection check so it stays in sync\r\n   * with both navigation state (breadcrumbs) and input changes.\r\n   */\r\n  get mergedActions(): UiButtonDescriptor[] {\r\n    const result: UiButtonDescriptor[] = [];\r\n\r\n    if (this.showBackButton) {\r\n      result.push({\r\n        id: '__ui-back',\r\n        label: this.backButtonConfig.label ?? 'Indietro',\r\n        icon: (this.backButtonConfig.icon as any) ?? 'arrow-left',\r\n        iconPosition: 'leading',\r\n        variant: (this.backButtonConfig.variant as any) ?? 'outline',\r\n        hidden: this.shouldHideBackButton(),\r\n        action: () => this.navigateBack(),\r\n      });\r\n    }\r\n\r\n    result.push(...this.actions);\r\n    return result;\r\n  }\r\n\r\n  /** Whether the footer should render (at least one non-hidden action exists). */\r\n  get hasVisibleActions(): boolean {\r\n    return this.mergedActions.some((a) => !a.hidden);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.syncFromActivatedRoute();\r\n\r\n    this.router.events\r\n      .pipe(\r\n        filter((event) => event instanceof NavigationEnd),\r\n        debounceTime(50),\r\n        takeUntilDestroyed(this.destroyRef),\r\n      )\r\n      .subscribe(() => this.syncFromActivatedRoute());\r\n  }\r\n\r\n  /** @internal Allinea breadcrumb service e flag layout alla rotta corrente. */\r\n  private syncFromActivatedRoute(): void {\r\n    this.refreshRouteSnapshotFlags();\r\n    this.breadcrumbService.getBreadcrumbsForRoute(this.activatedRoute);\r\n  }\r\n\r\n  /** @internal Legge `breadcrumbOff`, `footerNavOff`, `id` dalla catena `pathFromRoot` / foglia. */\r\n  private refreshRouteSnapshotFlags(): void {\r\n    const deepest = this.deepestChildRoute(this.activatedRoute);\r\n\r\n    let breadcrumbOff = false;\r\n    let footerNavOff = false;\r\n    for (const seg of deepest.pathFromRoot) {\r\n      const d = seg.snapshot.data as Record<string, unknown> | undefined;\r\n      if (!d) continue;\r\n      // biome-ignore lint/complexity/useLiteralKeys: chiavi documentate in UiBaseLayoutRouteData\r\n      if (d['breadcrumbOff'] === true) breadcrumbOff = true;\r\n      // biome-ignore lint/complexity/useLiteralKeys: chiavi documentate in UiBaseLayoutRouteData\r\n      if (d['footerNavOff'] === true) footerNavOff = true;\r\n    }\r\n\r\n    let routeId: string | null = null;\r\n    let cursor: ActivatedRoute | null = deepest;\r\n    while (cursor) {\r\n      const raw = cursor.snapshot.data?.['id'];\r\n      if (typeof raw === 'string' && raw.length > 0) {\r\n        routeId = raw;\r\n        break;\r\n      }\r\n      cursor = cursor.parent;\r\n    }\r\n\r\n    this.routeSnapshotFlags.set({ breadcrumbOff, footerNavOff, routeId });\r\n  }\r\n\r\n  /** @internal Percorre fino al `ActivatedRoute` foglia sotto il punto di iniezione. */\r\n  private deepestChildRoute(route: ActivatedRoute): ActivatedRoute {\r\n    let deepest = route;\r\n    while (deepest.firstChild) {\r\n      deepest = deepest.firstChild;\r\n    }\r\n    return deepest;\r\n  }\r\n\r\n  /** @internal Determina se il back button deve essere nascosto per la rotta corrente. */\r\n  private shouldHideBackButton(): boolean {\r\n    const currentPath = this.router.url.split('?')[0].split('#')[0];\r\n    if (currentPath === this.homeRoute) {\r\n      return true;\r\n    }\r\n\r\n    const deepestRoute = this.deepestChildRoute(this.activatedRoute);\r\n\r\n    // biome-ignore lint/complexity/useLiteralKeys: <explanation>\r\n    if (deepestRoute.snapshot.data?.['hideBackButton'] === true) {\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  /** @internal Naviga al breadcrumb genitore o esegue il fallback alla home route. */\r\n  private navigateBack(): void {\r\n    this.breadcrumbService.navigateBack(this.homeRoute);\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,6 @@
+/**
+ * @module ng-ui-system/base-layout
+ * Types and interfaces for UiBaseLayout component.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1sYXlvdXQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2Jhc2UtbGF5b3V0L2Jhc2UtbGF5b3V0LnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbW9kdWxlIG5nLXVpLXN5c3RlbS9iYXNlLWxheW91dFxyXG4gKiBUeXBlcyBhbmQgaW50ZXJmYWNlcyBmb3IgVWlCYXNlTGF5b3V0IGNvbXBvbmVudC5cclxuICovXHJcblxyXG5pbXBvcnQgeyBVaUJ1dHRvbkRlc2NyaXB0b3IsIFVpQnV0dG9uQXJlYUFsaWduIH0gZnJvbSAnLi4vYnV0dG9uL2J1dHRvbi50eXBlcyc7XHJcblxyXG4vLyBSZS1leHBvcnQgZm9yIGNvbnN1bWVyIGNvbnZlbmllbmNlXHJcbmV4cG9ydCB7IFVpQnV0dG9uRGVzY3JpcHRvciwgVWlCdXR0b25BcmVhQWxpZ24gfTtcclxuXHJcbi8qKlxyXG4gKiBDaGlhdmkgb3B6aW9uYWxpIGRpIGBkYXRhYCBzdWxsYSByb3R0YSBhdHRpdmEgcmljb25vc2NpdXRlIGRhIGBVaUJhc2VMYXlvdXRDb21wb25lbnRgLlxyXG4gKlxyXG4gKiAtIGBpZGA6IHN0ZXNzYSByaXNhbGl0YSB1c2F0YSBkYWkgYnJlYWRjcnVtYiAoZGFsIHNlZ21lbnRvIGZvZ2xpYSB2ZXJzbyBpbCByb290OiBwcmltbyBgaWRgIHRyb3ZhdG8pLlxyXG4gKiAtIGBicmVhZGNydW1iT2ZmYCAvIGBmb290ZXJOYXZPZmZgOiBzZSBgdHJ1ZWAgc3UgKipxdWFsc2lhc2kqKiBzZWdtZW50byBpbiBgcGF0aEZyb21Sb290YCwgbOKAmWFyZWEgdmllbmUgbmFzY29zdGEuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFVpQmFzZUxheW91dFJvdXRlRGF0YSB7XHJcbiAgLyoqIElkZW50aWZpY2F0aXZvIHN0YWJpbGUgZGVsbGEgcm90dGE7IHJlc28gY29tZSBgZGF0YS1yb3V0ZS1pZGAgc3VsIHdyYXBwZXIgYC51aS1iYXNlLWxheW91dGAuICovXHJcbiAgaWQ/OiBzdHJpbmc7XHJcbiAgLyoqIFNlIGB0cnVlYCwgbm9uIHZpZW5lIHJlbmRlcml6emF0byBgdWktcGFnZS1oZWFkZXJgIChicmVhZGNydW1iIGUgdGl0b2xvKS4gKi9cclxuICBicmVhZGNydW1iT2ZmPzogYm9vbGVhbjtcclxuICAvKiogU2UgYHRydWVgLCBub24gdmllbmUgcmVuZGVyaXp6YXRhIGxhIGJhcnJhIGB1aS1iYXNlLWxheW91dF9fZm9vdGVyYCAoYXppb25pIC8gaW5kaWV0cm8pLiAqL1xyXG4gIGZvb3Rlck5hdk9mZj86IGJvb2xlYW47XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBDb25maWd1cmF0aW9uIGZvciB0aGUgYXV0b21hdGljIFwiYmFja1wiIGJ1dHRvbiByZW5kZXJlZCBpbiB0aGUgZm9vdGVyIGFjdGlvbiBhcmVhLlxyXG4gKlxyXG4gKiBAdXNhZ2VOb3Rlc1xyXG4gKiBgYGB0eXBlc2NyaXB0XHJcbiAqIGNvbnN0IGJhY2tDb25maWc6IFVpQmFja0J1dHRvbkNvbmZpZyA9IHtcclxuICogICBsYWJlbDogJ0luZGlldHJvJyxcclxuICogICBpY29uOiAnYXJyb3ctbGVmdCcsXHJcbiAqICAgdmFyaWFudDogJ291dGxpbmUnLFxyXG4gKiB9O1xyXG4gKiBgYGBcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgVWlCYWNrQnV0dG9uQ29uZmlnIHtcclxuICAvKiogTGFiZWwgdGV4dCBmb3IgdGhlIGJhY2sgYnV0dG9uLiBAZGVmYXVsdCAnSW5kaWV0cm8nICovXHJcbiAgbGFiZWw/OiBzdHJpbmc7XHJcbiAgLyoqIEx1Y2lkZSBpY29uIG5hbWUuIEBkZWZhdWx0ICdhcnJvdy1sZWZ0JyAqL1xyXG4gIGljb24/OiBzdHJpbmc7XHJcbiAgLyoqIFZpc3VhbCB2YXJpYW50LiBAZGVmYXVsdCAnb3V0bGluZScgKi9cclxuICB2YXJpYW50Pzogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/base-layout/lib/components/base-layout/index.mjs

@@ -0,0 +1,14 @@
+/**
+ * ng-ui-system — Base Layout entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiBaseLayoutComponent,
+ *   UiBackButtonConfig,
+ * } from 'ng-ui-system';
+ * ```
+ */
+// Components
+export { UiBaseLayoutComponent } from './base-layout.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2Jhc2UtbGF5b3V0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFFSCxhQUFhO0FBQ2IsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0seUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogbmctdWktc3lzdGVtIOKAlCBCYXNlIExheW91dCBlbnRyeSBwb2ludC5cclxuICpcclxuICogQGV4YW1wbGVcclxuICogYGBgdHlwZXNjcmlwdFxyXG4gKiBpbXBvcnQge1xyXG4gKiAgIFVpQmFzZUxheW91dENvbXBvbmVudCxcclxuICogICBVaUJhY2tCdXR0b25Db25maWcsXHJcbiAqIH0gZnJvbSAnbmctdWktc3lzdGVtJztcclxuICogYGBgXHJcbiAqL1xyXG5cclxuLy8gQ29tcG9uZW50c1xyXG5leHBvcnQgeyBVaUJhc2VMYXlvdXRDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UtbGF5b3V0LmNvbXBvbmVudCc7XHJcblxyXG4vLyBUeXBlc1xyXG5leHBvcnQgeyBVaUJhY2tCdXR0b25Db25maWcsIFVpQmFzZUxheW91dFJvdXRlRGF0YSB9IGZyb20gJy4vYmFzZS1sYXlvdXQudHlwZXMnO1xyXG4iXX0=

package/esm2022/base-layout/lib/components/blackbox/blackbox-fingerprint.service.mjs

@@ -0,0 +1,116 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Fingerprint service — generates a stable device/browser hash
+ * using the open-source FingerprintJS library (MIT, no API key required).
+ *
+ * The fingerprint is computed once and cached in `localStorage` under
+ * the key `__ui_bb_fp` to avoid redundant recalculations.
+ */
+import { Injectable, inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+/** localStorage key for the cached fingerprint. */
+const FP_CACHE_KEY = '__ui_bb_fp';
+/**
+ * Generates and caches a stable browser/device fingerprint.
+ *
+ * Uses `@fingerprintjs/fingerprintjs` (open-source, MIT) which analyses
+ * canvas rendering, WebGL, audio context, screen properties, timezone,
+ * user-agent, and other browser signals to produce a stable hash.
+ *
+ * @usageNotes
+ * ```typescript
+ * const fp = inject(UiBlackboxFingerprintService);
+ * const hash = await fp.getFingerprint();
+ * // => "a1b2c3d4e5f6..." (stable across sessions)
+ * ```
+ */
+export class UiBlackboxFingerprintService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.cached = null;
+    }
+    /**
+     * Returns the stable fingerprint for this device/browser.
+     *
+     * On first call, loads FingerprintJS dynamically, computes the hash,
+     * and caches it in both memory and `localStorage`.
+     * Subsequent calls return the cached value immediately.
+     */
+    async getFingerprint() {
+        // Return cached value if available
+        if (this.cached) {
+            return this.cached;
+        }
+        // SSR guard
+        if (!isPlatformBrowser(this.platformId)) {
+            return 'ssr-placeholder';
+        }
+        // Try localStorage cache first
+        try {
+            const stored = localStorage.getItem(FP_CACHE_KEY);
+            if (stored) {
+                this.cached = stored;
+                return stored;
+            }
+        }
+        catch {
+            // localStorage may be unavailable (privacy mode, quota exceeded)
+        }
+        // Compute fingerprint via FingerprintJS
+        try {
+            const FingerprintJS = await import('@fingerprintjs/fingerprintjs');
+            const agent = await FingerprintJS.load();
+            const result = await agent.get();
+            this.cached = result.visitorId;
+            // Persist to localStorage
+            try {
+                localStorage.setItem(FP_CACHE_KEY, this.cached);
+            }
+            catch {
+                // Silently ignore storage errors
+            }
+            return this.cached;
+        }
+        catch {
+            // Fallback: generate a pseudo-fingerprint from available signals
+            const fallback = this.generateFallbackFingerprint();
+            this.cached = fallback;
+            try {
+                localStorage.setItem(FP_CACHE_KEY, fallback);
+            }
+            catch {
+                // Silently ignore
+            }
+            return fallback;
+        }
+    }
+    /**
+     * Fallback fingerprint when FingerprintJS is unavailable.
+     * Combines basic browser signals into a hash.
+     * @internal
+     */
+    generateFallbackFingerprint() {
+        const signals = [
+            navigator.userAgent,
+            navigator.language,
+            screen.width + 'x' + screen.height,
+            screen.colorDepth?.toString() ?? '',
+            Intl.DateTimeFormat().resolvedOptions().timeZone,
+            navigator.hardwareConcurrency?.toString() ?? '',
+        ].join('|');
+        // Simple string hash (djb2)
+        let hash = 5381;
+        for (let i = 0; i < signals.length; i++) {
+            hash = ((hash << 5) + hash + signals.charCodeAt(i)) >>> 0;
+        }
+        return hash.toString(36).padStart(12, '0');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxFingerprintService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxFingerprintService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxFingerprintService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blackbox-fingerprint.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/blackbox/blackbox-fingerprint.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @module ng-ui-system/blackbox\r\n * Fingerprint service — generates a stable device/browser hash\r\n * using the open-source FingerprintJS library (MIT, no API key required).\r\n *\r\n * The fingerprint is computed once and cached in `localStorage` under\r\n * the key `__ui_bb_fp` to avoid redundant recalculations.\r\n */\r\n\r\nimport { Injectable, inject, PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformBrowser } from '@angular/common';\r\nimport type { UiBlackboxFingerprint } from './blackbox.types';\r\n\r\n/** localStorage key for the cached fingerprint. */\r\nconst FP_CACHE_KEY = '__ui_bb_fp';\r\n\r\n/**\r\n * Generates and caches a stable browser/device fingerprint.\r\n *\r\n * Uses `@fingerprintjs/fingerprintjs` (open-source, MIT) which analyses\r\n * canvas rendering, WebGL, audio context, screen properties, timezone,\r\n * user-agent, and other browser signals to produce a stable hash.\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * const fp = inject(UiBlackboxFingerprintService);\r\n * const hash = await fp.getFingerprint();\r\n * // => \"a1b2c3d4e5f6...\" (stable across sessions)\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiBlackboxFingerprintService {\r\n  private readonly platformId = inject(PLATFORM_ID);\r\n  private cached: UiBlackboxFingerprint | null = null;\r\n\r\n  /**\r\n   * Returns the stable fingerprint for this device/browser.\r\n   *\r\n   * On first call, loads FingerprintJS dynamically, computes the hash,\r\n   * and caches it in both memory and `localStorage`.\r\n   * Subsequent calls return the cached value immediately.\r\n   */\r\n  async getFingerprint(): Promise<UiBlackboxFingerprint> {\r\n    // Return cached value if available\r\n    if (this.cached) {\r\n      return this.cached;\r\n    }\r\n\r\n    // SSR guard\r\n    if (!isPlatformBrowser(this.platformId)) {\r\n      return 'ssr-placeholder';\r\n    }\r\n\r\n    // Try localStorage cache first\r\n    try {\r\n      const stored = localStorage.getItem(FP_CACHE_KEY);\r\n      if (stored) {\r\n        this.cached = stored;\r\n        return stored;\r\n      }\r\n    } catch {\r\n      // localStorage may be unavailable (privacy mode, quota exceeded)\r\n    }\r\n\r\n    // Compute fingerprint via FingerprintJS\r\n    try {\r\n      const FingerprintJS = await import('@fingerprintjs/fingerprintjs');\r\n      const agent = await FingerprintJS.load();\r\n      const result = await agent.get();\r\n      this.cached = result.visitorId;\r\n\r\n      // Persist to localStorage\r\n      try {\r\n        localStorage.setItem(FP_CACHE_KEY, this.cached);\r\n      } catch {\r\n        // Silently ignore storage errors\r\n      }\r\n\r\n      return this.cached;\r\n    } catch {\r\n      // Fallback: generate a pseudo-fingerprint from available signals\r\n      const fallback = this.generateFallbackFingerprint();\r\n      this.cached = fallback;\r\n\r\n      try {\r\n        localStorage.setItem(FP_CACHE_KEY, fallback);\r\n      } catch {\r\n        // Silently ignore\r\n      }\r\n\r\n      return fallback;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fallback fingerprint when FingerprintJS is unavailable.\r\n   * Combines basic browser signals into a hash.\r\n   * @internal\r\n   */\r\n  private generateFallbackFingerprint(): string {\r\n    const signals = [\r\n      navigator.userAgent,\r\n      navigator.language,\r\n      screen.width + 'x' + screen.height,\r\n      screen.colorDepth?.toString() ?? '',\r\n      Intl.DateTimeFormat().resolvedOptions().timeZone,\r\n      navigator.hardwareConcurrency?.toString() ?? '',\r\n    ].join('|');\r\n\r\n    // Simple string hash (djb2)\r\n    let hash = 5381;\r\n    for (let i = 0; i < signals.length; i++) {\r\n      hash = ((hash << 5) + hash + signals.charCodeAt(i)) >>> 0;\r\n    }\r\n    return hash.toString(36).padStart(12, '0');\r\n  }\r\n}\r\n"]}