@gnggln/ng-ui-system 1.0.0-alpha.14 → 1.0.0-alpha.16

package/base-layout/lib/components/blackbox/blackbox.service.d.ts

@@ -7,7 +7,7 @@
  * - Root singleton (`providedIn: 'root'`)
  * - On first inject: generates fingerprint, creates session, subscribes to Router events
  * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
- * - `window:beforeunload` triggers a final synchronous flush
+ * - `window:beforeunload` triggers a final best-effort async flush
  */
 import { OnDestroy } from '@angular/core';
 import { UiBlackboxConfig, UiBlackboxFormTrackingConfig, UiBlackboxSession, UiBlackboxFormEvent, UiBlackboxHttpCall } from './blackbox.types';
@@ -136,18 +136,6 @@ export declare class UiBlackboxService implements OnDestroy {
      * @internal
      */
     private flush;
-    /**
-     * Synchronous flush for `beforeunload`.
-     * Falls back to a best-effort approach since IndexedDB is async.
-     * @internal
-     */
-    private flushSync;
-    /**
-     * Recover sessions that were saved to localStorage during `beforeunload`
-     * and persist them to IndexedDB. Called on next service init.
-     * @internal
-     */
-    private recoverPendingSessions;
     /** Generate a UUID v4. */
     private generateUuid;
     ngOnDestroy(): void;

package/blackbox/lib/components/blackbox/blackbox.service.d.ts

@@ -7,7 +7,7 @@
  * - Root singleton (`providedIn: 'root'`)
  * - On first inject: generates fingerprint, creates session, subscribes to Router events
  * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
- * - `window:beforeunload` triggers a final synchronous flush
+ * - `window:beforeunload` triggers a final best-effort async flush
  */
 import { OnDestroy } from '@angular/core';
 import { UiBlackboxConfig, UiBlackboxFormTrackingConfig, UiBlackboxSession, UiBlackboxFormEvent, UiBlackboxHttpCall } from './blackbox.types';
@@ -136,18 +136,6 @@ export declare class UiBlackboxService implements OnDestroy {
      * @internal
      */
     private flush;
-    /**
-     * Synchronous flush for `beforeunload`.
-     * Falls back to a best-effort approach since IndexedDB is async.
-     * @internal
-     */
-    private flushSync;
-    /**
-     * Recover sessions that were saved to localStorage during `beforeunload`
-     * and persist them to IndexedDB. Called on next service init.
-     * @internal
-     */
-    private recoverPendingSessions;
     /** Generate a UUID v4. */
     private generateUuid;
     ngOnDestroy(): void;

package/button/lib/components/blackbox/blackbox.service.d.ts

@@ -7,7 +7,7 @@
  * - Root singleton (`providedIn: 'root'`)
  * - On first inject: generates fingerprint, creates session, subscribes to Router events
  * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
- * - `window:beforeunload` triggers a final synchronous flush
+ * - `window:beforeunload` triggers a final best-effort async flush
  */
 import { OnDestroy } from '@angular/core';
 import { UiBlackboxConfig, UiBlackboxFormTrackingConfig, UiBlackboxSession, UiBlackboxFormEvent, UiBlackboxHttpCall } from './blackbox.types';
@@ -136,18 +136,6 @@ export declare class UiBlackboxService implements OnDestroy {
      * @internal
      */
     private flush;
-    /**
-     * Synchronous flush for `beforeunload`.
-     * Falls back to a best-effort approach since IndexedDB is async.
-     * @internal
-     */
-    private flushSync;
-    /**
-     * Recover sessions that were saved to localStorage during `beforeunload`
-     * and persist them to IndexedDB. Called on next service init.
-     * @internal
-     */
-    private recoverPendingSessions;
     /** Generate a UUID v4. */
     private generateUuid;
     ngOnDestroy(): void;

package/crud-table/lib/components/blackbox/blackbox.service.d.ts

@@ -7,7 +7,7 @@
  * - Root singleton (`providedIn: 'root'`)
  * - On first inject: generates fingerprint, creates session, subscribes to Router events
  * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
- * - `window:beforeunload` triggers a final synchronous flush
+ * - `window:beforeunload` triggers a final best-effort async flush
  */
 import { OnDestroy } from '@angular/core';
 import { UiBlackboxConfig, UiBlackboxFormTrackingConfig, UiBlackboxSession, UiBlackboxFormEvent, UiBlackboxHttpCall } from './blackbox.types';
@@ -136,18 +136,6 @@ export declare class UiBlackboxService implements OnDestroy {
      * @internal
      */
     private flush;
-    /**
-     * Synchronous flush for `beforeunload`.
-     * Falls back to a best-effort approach since IndexedDB is async.
-     * @internal
-     */
-    private flushSync;
-    /**
-     * Recover sessions that were saved to localStorage during `beforeunload`
-     * and persist them to IndexedDB. Called on next service init.
-     * @internal
-     */
-    private recoverPendingSessions;
     /** Generate a UUID v4. */
     private generateUuid;
     ngOnDestroy(): void;

package/crud-table/lib/components/form-builder/form-builder.component.d.ts

@@ -44,6 +44,8 @@ export declare class UiFormBuilderComponent implements OnInit, OnChanges, OnDest
     private readonly blackbox;
     /** @internal Router inject for BlackBox route context. */
     private readonly bbRouter;
+    /** @internal Optional Logger service — logs form actions when available. */
+    private readonly logger;
     private readonly destroy$;
     private valueChangeSub?;
     /** @internal Listener cleanup for BlackBox focus/blur tracking. */

package/crud-table/lib/components/form-builder/types/field.types.d.ts

@@ -273,9 +273,16 @@ export interface UiFormFieldDescriptor {
     searchable?: boolean;
     /** Mostra pulsante "Seleziona tutto" per multiselect. */
     allowSelectAll?: boolean;
-    /** Callback per recupero asincrono di opzioni filtrate per query. */
+    /**
+     * Con `searchable: true` su `select`/`text`, ogni `input` dell'autocomplete
+     * invoca la callback: il risultato sostituisce l'elenco opzioni mostrato.
+     */
     asyncOptions?: (query: string) => Promise<UiFieldOption[]>;
-    /** Callback per recupero asincrono di opzioni per ID (prevalorizzazione). */
+    /**
+     * Contratto per risolvere opzioni da id (es. prefill da API). Il Form Builder
+     * Angular attuale non invoca questa callback; l'app può comporre le opzioni
+     * in `options` o collegarla a logica custom.
+     */
     recoverAsyncValues?: (ids: any[]) => Promise<UiFieldOption[]>;
     /** Generazione dinamica di opzioni. */
     dynamicOptions?: UiDynamicOptionsConfig;

package/crud-table/lib/components/form-builder/types/schema.types.d.ts

@@ -191,6 +191,8 @@ export interface UiWizardConfig {
     onStepSave?: (stepData: Record<string, any>, stepNumber: number) => Promise<void> | void;
     /** Mostra pulsanti di navigazione (precedente/successivo). @default true */
     showNavigationButtons?: boolean;
+    /** Posizione dei pulsanti di navigazione. @default 'bottom' */
+    navigationPosition?: 'top' | 'bottom' | 'both';
     /** Label personalizzate per i pulsanti del wizard. */
     buttonLabels?: {
         previous?: string;

package/crud-table/lib/core/logging/logger.config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module ng-ui-system/core/logging
+ * Configurazione IndexedDB per UiLoggerService.
+ * Pattern omologato a action-logger.config.ts del progetto Siform-PAL.
+ */
+import type { UiLogLevel } from './logger.types';
+/** Durata default retention log (7 giorni). */
+export declare const UI_LOGGER_DEFAULT_TTL_MS: number;
+/** Nome database IndexedDB. */
+export declare const UI_LOGGER_IDB_NAME = "ng-ui-system-logs";
+/** Versione database (incrementare su schema change). */
+export declare const UI_LOGGER_IDB_VERSION = 1;
+/** Nome object store. */
+export declare const UI_LOGGER_IDB_STORE = "entries";
+/** Max entry totali per cleanup automatico. */
+export declare const UI_LOGGER_MAX_ENTRIES = 10000;
+/** Livelli di log ordinati per severità crescente. */
+export declare const UI_LOGGER_LEVELS: readonly UiLogLevel[];

package/crud-table/lib/core/logging/logger.service.d.ts

@@ -0,0 +1,75 @@
+import type { UiLogCategory, UiLogEntry, UiLogFilter, UiLogLevel, UiLogSummary, UiLoggerConfig } from './logger.types';
+import * as i0 from "@angular/core";
+/**
+ * Logger centralizzato per componenti ng-ui-system.
+ * Persiste su IndexedDB con cleanup automatico.
+ */
+export declare class UiLoggerService {
+    private readonly platformId;
+    private dbPromise;
+    /** Stato toggle runtime. */
+    readonly enabled: import("@angular/core").WritableSignal<boolean>;
+    /** Configurazione runtime. */
+    private config;
+    /** True se IndexedDB disponibile e siamo in browser. */
+    private idbSupported;
+    /** Rileva se logging attivo (default: true in dev se non production). */
+    private detectEnabled;
+    /** Abilita/disabilita logging runtime. */
+    setEnabled(value: boolean): void;
+    /** Configura il logger. */
+    configure(config: Partial<UiLoggerConfig>): void;
+    /**
+     * Log generico con controllo enabled e livello.
+     */
+    log(category: UiLogCategory, level: UiLogLevel, action: string, payload?: Record<string, unknown>, duration?: number): void;
+    /**
+     * Log azione form (submit, reset, valueChange, etc).
+     */
+    logFormAction(action: 'init' | 'submit' | 'reset' | 'valueChange' | 'validationChange' | 'customEvent' | 'destroy', payload: {
+        schemaId: string;
+        [key: string]: unknown;
+    }): void;
+    /**
+     * Log azione wizard (stepChange, complete, validationFailed, etc).
+     */
+    logWizardAction(action: 'init' | 'stepChange' | 'stepComplete' | 'stepValidationFailed' | 'complete' | 'navigation' | 'save' | 'valueChange' | 'keyboardNavigation' | 'destroy', payload: {
+        wizardId?: string;
+        step?: number;
+        [key: string]: unknown;
+    }): void;
+    /**
+     * Log errore.
+     */
+    logError(error: Error | unknown, context?: Record<string, unknown>): void;
+    /**
+     * Log debug (solo se enabled e minLevel <= debug).
+     */
+    debug(category: UiLogCategory, action: string, payload?: Record<string, unknown>): void;
+    private persist;
+    /** Recupera userId da localStorage se disponibile. */
+    private getUserId;
+    /** Verifica se il livello deve essere loggato in base a minLevel. */
+    private shouldLogLevel;
+    /**
+     * Recupera log con filtri.
+     */
+    query(filter?: UiLogFilter): Promise<UiLogEntry[]>;
+    /**
+     * Riepilogo log per dashboard.
+     */
+    summary(): Promise<UiLogSummary>;
+    /**
+     * Cancella log più vecchi di TTL.
+     */
+    purgeOld(): Promise<number>;
+    /**
+     * Cancella tutti i log.
+     */
+    clear(): Promise<void>;
+    private openDb;
+    private cleanupIfNeeded;
+    private applyFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiLoggerService>;
+}

package/crud-table/lib/core/logging/logger.types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @module ng-ui-system/core/logging
+ * Tipologie per il sistema di logging centralizzato della libreria.
+ * Pattern omologato a ActionLoggerService del progetto Siform-PAL.
+ */
+/**
+ * Categorie di log per filtraggio e organizzazione.
+ */
+export type UiLogCategory = 'form' | 'wizard' | 'navigation' | 'system' | 'error';
+/**
+ * Livelli di severità log.
+ */
+export type UiLogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Entry singola nel log. Persistita su IndexedDB.
+ */
+export interface UiLogEntry {
+    /** ID univoco (timestamp + random). */
+    id: string;
+    /** Categoria log. */
+    category: UiLogCategory;
+    /** Livello severità. */
+    level: UiLogLevel;
+    /** Azione/etichetta descrittiva (es. 'form_submit', 'step_change'). */
+    action: string;
+    /** Payload dati (schema id, step, valori, errori). */
+    payload?: Record<string, unknown>;
+    /** Timestamp creazione (ms). */
+    timestamp: number;
+    /** Durata operazione (ms), opzionale. */
+    duration?: number;
+    /** URL corrente al momento del log. */
+    url: string;
+    /** User ID se disponibile. */
+    userId?: string;
+}
+/**
+ * Filtri per query log.
+ */
+export interface UiLogFilter {
+    category?: UiLogCategory;
+    level?: UiLogLevel;
+    action?: string;
+    from?: number;
+    to?: number;
+    limit?: number;
+}
+/**
+ * Riepilogo log per UI admin/debug.
+ */
+export interface UiLogSummary {
+    total: number;
+    byCategory: Record<UiLogCategory, number>;
+    byLevel: Record<UiLogLevel, number>;
+    oldest: number;
+    newest: number;
+}
+/**
+ * Configurazione runtime del logger.
+ */
+export interface UiLoggerConfig {
+    /** Abilita/disabilita logging. Default: true in dev, false in production. */
+    enabled: boolean;
+    /** Livello minimo da loggare. */
+    minLevel: UiLogLevel;
+    /** Durata retention log in ms. Default: 7 giorni. */
+    ttlMs: number;
+    /** Max entry totali per cleanup automatico. */
+    maxEntries: number;
+}

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

@@ -7,7 +7,7 @@
  * - Root singleton (`providedIn: 'root'`)
  * - On first inject: generates fingerprint, creates session, subscribes to Router events
  * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
- * - `window:beforeunload` triggers a final synchronous flush
+ * - `window:beforeunload` triggers a final best-effort async flush
  */
 import { Injectable, inject, PLATFORM_ID, NgZone, } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
@@ -97,8 +97,11 @@ export class UiBlackboxService {
         // Setup periodic flush (outside Angular zone to avoid triggering CD)
         this.zone.runOutsideAngular(() => {
             this.flushTimerId = setInterval(() => this.flush(), this.config.flushIntervalMs);
-            // Final flush on tab close
-            this.beforeUnloadHandler = () => this.flushSync();
+            // Best-effort flush on tab close (IndexedDB is async, no sync fallback)
+            this.beforeUnloadHandler = () => {
+                this.session.endedAt = Date.now();
+                void this.flush();
+            };
             window.addEventListener('beforeunload', this.beforeUnloadHandler);
         });
         this.initialised = true;
@@ -284,58 +287,6 @@ export class UiBlackboxService {
             console.warn('[UiBlackbox] Storage flush failed:', e);
         }
     }
-    /**
-     * Synchronous flush for `beforeunload`.
-     * Falls back to a best-effort approach since IndexedDB is async.
-     * @internal
-     */
-    flushSync() {
-        if (!this.initialised)
-            return;
-        this.session.endedAt = Date.now();
-        // Use sendBeacon-like approach: serialise session to localStorage
-        // as a fallback that can be recovered on next load.
-        // The proper IndexedDB flush is async and may not complete on unload.
-        try {
-            const key = `__ui_bb_pending_${this.session.sessionId}`;
-            const data = JSON.stringify(this.session);
-            localStorage.setItem(key, data);
-        }
-        catch {
-            // Best effort — quota may be exceeded
-        }
-    }
-    // ─── Pending session recovery ──────────────────────────────────────
-    /**
-     * Recover sessions that were saved to localStorage during `beforeunload`
-     * and persist them to IndexedDB. Called on next service init.
-     * @internal
-     */
-    async recoverPendingSessions() {
-        if (!isPlatformBrowser(this.platformId))
-            return;
-        const prefix = '__ui_bb_pending_';
-        const keys = [];
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key?.startsWith(prefix)) {
-                keys.push(key);
-            }
-        }
-        for (const key of keys) {
-            try {
-                const data = localStorage.getItem(key);
-                if (data) {
-                    const session = JSON.parse(data);
-                    await this.storage.saveSession(session);
-                }
-                localStorage.removeItem(key);
-            }
-            catch {
-                localStorage.removeItem(key);
-            }
-        }
-    }
     // ─── Utilities ─────────────────────────────────────────────────────
     /** Generate a UUID v4. */
     generateUuid() {
@@ -360,7 +311,7 @@ export class UiBlackboxService {
             window.removeEventListener('beforeunload', this.beforeUnloadHandler);
         }
         // Final flush
-        this.flushSync();
+        void this.flush();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxService, providedIn: 'root' }); }
@@ -369,4 +320,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blackbox.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/blackbox/blackbox.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,MAAM,EACN,WAAW,EAEX,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EASL,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;;AAEtE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,OAAO,iBAAiB;IAoB5B;QAnBiB,eAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QACjC,WAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACxB,SAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACtB,gBAAW,GAAG,MAAM,CAAC,4BAA4B,CAAC,CAAC;QACnD,YAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;QAE3C,aAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;QACxC,WAAM,GAAqB,EAAE,GAAG,oBAAoB,EAAE,CAAC;QAIvD,gBAAW,GAA0B,IAAI,CAAC;QAC1C,gBAAW,GAAG,KAAK,CAAC;QAE5B,sEAAsE;QAC9D,WAAM,GAA4B,EAAE,CAAC;QACrC,iBAAY,GAA0C,IAAI,CAAC;QAC3D,wBAAmB,GAAwB,IAAI,CAAC;QAGtD,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;IACH,CAAC;IAED,sEAAsE;IAE9D,KAAK,CAAC,IAAI;QAChB,sBAAsB;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACtC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QAEnD,IAAI,CAAC,OAAO,GAAG;YACb,SAAS;YACT,WAAW,EAAE,EAAE;YACf,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,KAAK,EAAE,EAAE;YACT,UAAU,EAAE,EAAE;YACd,KAAK,EAAE,EAAE;SACV,CAAC;QAEF,uCAAuC;QACvC,IAAI,CAAC,WAAW,GAAG;YACjB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG;YACtB,OAAO,EAAE,EAAE;SACZ,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAE1C,iCAAiC;QACjC,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,CAAC,EAAsB,EAAE,CAAC,CAAC,YAAY,aAAa,CAAC,EAC7D,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB;aACA,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC;YAC9C,IAAI,CAAC,WAAW,GAAG;gBACjB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;gBACrB,KAAK,EAAE,KAAK,CAAC,iBAAiB;gBAC9B,aAAa;gBACb,OAAO,EAAE,EAAE;aACZ,CAAC;YACF,IAAI,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEL,qEAAqE;QACrE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC,YAAY,GAAG,WAAW,CAC7B,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAClB,IAAI,CAAC,MAAM,CAAC,eAAe,CAC5B,CAAC;YAEF,2BAA2B;YAC3B,IAAI,CAAC,mBAAmB,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YAClD,MAAM,CAAC,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED,sEAAsE;IAEtE;;;OAGG;IACH,SAAS,CAAC,MAAkH;QAC1H,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,IAAI,CAAC,MAAM;YACd,GAAG,MAAM;YACT,YAAY,EAAE;gBACZ,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY;gBAC3B,GAAG,CAAC,MAAM,CAAC,YAAY,IAAI,EAAE,CAAC;aAC/B;SACF,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAEvD,wCAAwC;QACxC,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YAC/B,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;gBAC/B,IAAI,CAAC,YAAY,GAAG,WAAW,CAC7B,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAClB,IAAI,CAAC,MAAM,CAAC,eAAe,CAC5B,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,6DAA6D;IAC7D,SAAS;QACP,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED,sEAAsE;IAEtE;;;;;;;;OAQG;IACH,WAAW,CACT,OAAe,EACf,IAAmD;QAEnD,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,MAAM,MAAM,GAAqB;YAC/B,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,IAAI,EAAE,OAAO;YACb,MAAM,EAAE;gBACN,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,SAAS;gBAC3B,EAAE,EAAE,IAAI,EAAE,EAAE;gBACZ,OAAO;gBACP,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC;aACnC;SACF,CAAC;QAEF,iEAAiE;QACjE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEvC,sCAAsC;QACtC,IAAI,CAAC,eAAe,CAAC;YACnB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;SAC1E,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,KAA0B;QACvC,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,IAAwB;QACpC,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,sEAAsE;IAEtE;;;OAGG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,iBAAiB;QACrB,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB;QACxB,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QACnD,OAAO,IAAI,CAAC,OAAO,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC;IAED,sEAAsE;IAEtE;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,cAAc;QAClB,8BAA8B;QAC9B,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;IAED,sEAAsE;IAEtE;;;OAGG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAC9B,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAClC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;IACjC,CAAC;IAED,sEAAsE;IAEtE;;;;OAIG;IACK,eAAe,CAAC,KAA4B;QAClD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACrD,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,KAAK;QACjB,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAE1D,eAAe;QACf,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAErC,mCAAmC;QACnC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBAC1B,uEAAuE;gBACvE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;oBAChD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;YACD,iEAAiE;YACjE,uEAAuE;QACzE,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,mDAAmD;YACnD,OAAO,CAAC,IAAI,CAAC,oCAAoC,EAAE,CAAC,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,SAAS;QACf,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAElC,kEAAkE;QAClE,oDAAoD;QACpD,sEAAsE;QACtE,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,mBAAmB,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACxD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1C,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,sCAAsC;QACxC,CAAC;IACH,CAAC;IAED,sEAAsE;IAEtE;;;;OAIG;IACK,KAAK,CAAC,sBAAsB;QAClC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO;QAEhD,MAAM,MAAM,GAAG,kBAAkB,CAAC;QAClC,MAAM,IAAI,GAAa,EAAE,CAAC;QAE1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,GAAG,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC5B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACjB,CAAC;QACH,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACvC,IAAI,IAAI,EAAE,CAAC;oBACT,MAAM,OAAO,GAAsB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBACpD,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;gBAC1C,CAAC;gBACD,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC/B,CAAC;YAAC,MAAM,CAAC;gBACP,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAED,sEAAsE;IAEtE,0BAA0B;IAClB,YAAY;QAClB,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;YACvD,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;QAC7B,CAAC;QACD,8BAA8B;QAC9B,OAAO,sCAAsC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE;YACnE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;YACnC,MAAM,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;YAC1C,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sEAAsE;IAEtE,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAEzB,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YAC/B,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACnC,CAAC;QAED,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,MAAM,CAAC,mBAAmB,CAAC,cAAc,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACvE,CAAC;QAED,cAAc;QACd,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;+GA3XU,iBAAiB;mHAAjB,iBAAiB,cADJ,MAAM;;4FACnB,iBAAiB;kBAD7B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/**\r\n * @module ng-ui-system/blackbox\r\n * Core BlackBox observability service — the main entry point for session\r\n * recording, event buffering, and export.\r\n *\r\n * Architecture:\r\n * - Root singleton (`providedIn: 'root'`)\r\n * - On first inject: generates fingerprint, creates session, subscribes to Router events\r\n * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB\r\n * - `window:beforeunload` triggers a final synchronous flush\r\n */\r\n\r\nimport {\r\n  Injectable,\r\n  inject,\r\n  PLATFORM_ID,\r\n  OnDestroy,\r\n  NgZone,\r\n} from '@angular/core';\r\nimport { isPlatformBrowser } from '@angular/common';\r\nimport { Router, NavigationEnd } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\nimport { filter, takeUntil } from 'rxjs/operators';\r\n\r\nimport {\r\n  UiBlackboxConfig,\r\n  UiBlackboxFormTrackingConfig,\r\n  UiBlackboxSession,\r\n  UiBlackboxStep,\r\n  UiBlackboxAction,\r\n  UiBlackboxFormEvent,\r\n  UiBlackboxHttpCall,\r\n  UiBlackboxBufferEvent,\r\n  UI_BLACKBOX_DEFAULTS,\r\n} from './blackbox.types';\r\nimport { UiBlackboxFingerprintService } from './blackbox-fingerprint.service';\r\nimport { UiBlackboxStorageService } from './blackbox-storage.service';\r\n\r\n/**\r\n * Central BlackBox observability service.\r\n *\r\n * Records navigation, UI interactions, form events, and HTTP calls\r\n * into compressed sessions stored in IndexedDB.\r\n *\r\n * @usageNotes\r\n * The service activates automatically when injected. Provide it at root level\r\n * and it will start recording immediately.\r\n *\r\n * ```typescript\r\n * // app.config.ts — just importing the service is enough\r\n * import { UiBlackboxService } from '@gnggln/ng-ui-system';\r\n *\r\n * export const appConfig: ApplicationConfig = {\r\n *   providers: [\r\n *     // The service is providedIn: 'root', so it's auto-provided.\r\n *     // To force eager initialisation:\r\n *     { provide: APP_INITIALIZER, useFactory: () => () => inject(UiBlackboxService), multi: true },\r\n *   ],\r\n * };\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiBlackboxService implements OnDestroy {\r\n  private readonly platformId = inject(PLATFORM_ID);\r\n  private readonly router = inject(Router);\r\n  private readonly zone = inject(NgZone);\r\n  private readonly fingerprint = inject(UiBlackboxFingerprintService);\r\n  private readonly storage = inject(UiBlackboxStorageService);\r\n\r\n  private readonly destroy$ = new Subject<void>();\r\n  private config: UiBlackboxConfig = { ...UI_BLACKBOX_DEFAULTS };\r\n\r\n  // ─── Session state ─────────────────────────────────────────────────\r\n  private session!: UiBlackboxSession;\r\n  private currentStep: UiBlackboxStep | null = null;\r\n  private initialised = false;\r\n\r\n  // ─── Centralised event buffer ──────────────────────────────────────\r\n  private buffer: UiBlackboxBufferEvent[] = [];\r\n  private flushTimerId: ReturnType<typeof setInterval> | null = null;\r\n  private beforeUnloadHandler: (() => void) | null = null;\r\n\r\n  constructor() {\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      this.init();\r\n    }\r\n  }\r\n\r\n  // ─── Initialisation ────────────────────────────────────────────────\r\n\r\n  private async init(): Promise<void> {\r\n    // Generate session ID\r\n    const sessionId = this.generateUuid();\r\n    const fp = await this.fingerprint.getFingerprint();\r\n\r\n    this.session = {\r\n      sessionId,\r\n      fingerprint: fp,\r\n      startedAt: Date.now(),\r\n      userAgent: navigator.userAgent,\r\n      steps: [],\r\n      formEvents: [],\r\n      calls: [],\r\n    };\r\n\r\n    // Create initial step from current URL\r\n    this.currentStep = {\r\n      timestamp: Date.now(),\r\n      route: this.router.url,\r\n      actions: [],\r\n    };\r\n    this.session.steps.push(this.currentStep);\r\n\r\n    // Subscribe to router navigation\r\n    this.router.events\r\n      .pipe(\r\n        filter((e): e is NavigationEnd => e instanceof NavigationEnd),\r\n        takeUntil(this.destroy$),\r\n      )\r\n      .subscribe((event) => {\r\n        const previousRoute = this.currentStep?.route;\r\n        this.currentStep = {\r\n          timestamp: Date.now(),\r\n          route: event.urlAfterRedirects,\r\n          previousRoute,\r\n          actions: [],\r\n        };\r\n        this.pushBufferEvent({ kind: 'step', payload: this.currentStep });\r\n      });\r\n\r\n    // Setup periodic flush (outside Angular zone to avoid triggering CD)\r\n    this.zone.runOutsideAngular(() => {\r\n      this.flushTimerId = setInterval(\r\n        () => this.flush(),\r\n        this.config.flushIntervalMs,\r\n      );\r\n\r\n      // Final flush on tab close\r\n      this.beforeUnloadHandler = () => this.flushSync();\r\n      window.addEventListener('beforeunload', this.beforeUnloadHandler);\r\n    });\r\n\r\n    this.initialised = true;\r\n  }\r\n\r\n  // ─── Public API: Configuration ─────────────────────────────────────\r\n\r\n  /**\r\n   * Update the BlackBox configuration.\r\n   * Can be called at any time; changes take effect immediately.\r\n   */\r\n  configure(config: Partial<Omit<UiBlackboxConfig, 'formTracking'>> & { formTracking?: Partial<UiBlackboxFormTrackingConfig> }): void {\r\n    this.config = {\r\n      ...this.config,\r\n      ...config,\r\n      formTracking: {\r\n        ...this.config.formTracking,\r\n        ...(config.formTracking ?? {}),\r\n      },\r\n    };\r\n    this.storage.setMaxStorageMb(this.config.maxStorageMb);\r\n\r\n    // Restart flush timer with new interval\r\n    if (this.flushTimerId !== null) {\r\n      clearInterval(this.flushTimerId);\r\n      this.zone.runOutsideAngular(() => {\r\n        this.flushTimerId = setInterval(\r\n          () => this.flush(),\r\n          this.config.flushIntervalMs,\r\n        );\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Returns the current configuration (readonly snapshot). */\r\n  getConfig(): Readonly<UiBlackboxConfig> {\r\n    return { ...this.config };\r\n  }\r\n\r\n  // ─── Public API: Tracking ──────────────────────────────────────────\r\n\r\n  /**\r\n   * Manually track a UI action (click).\r\n   *\r\n   * Called automatically by `UiButtonAreaComponent` and the `[uiTrack]` directive.\r\n   * Can also be called programmatically for custom interactions.\r\n   *\r\n   * @param trackId - Identifier for the action (e.g. button id, link name).\r\n   * @param meta - Optional metadata: `tag`, `text`, `id` of the element.\r\n   */\r\n  trackAction(\r\n    trackId: string,\r\n    meta?: { tag?: string; text?: string; id?: string },\r\n  ): void {\r\n    if (!this.initialised) return;\r\n\r\n    const action: UiBlackboxAction = {\r\n      timestamp: Date.now(),\r\n      type: 'click',\r\n      target: {\r\n        tag: meta?.tag ?? 'unknown',\r\n        id: meta?.id,\r\n        trackId,\r\n        text: meta?.text?.substring(0, 50),\r\n      },\r\n    };\r\n\r\n    // Add to current step immediately (for in-memory session access)\r\n    this.currentStep?.actions.push(action);\r\n\r\n    // Also push to buffer for persistence\r\n    this.pushBufferEvent({\r\n      kind: 'action',\r\n      payload: { ...action, route: this.currentStep?.route ?? this.router.url },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Track a form interaction event.\r\n   *\r\n   * Called automatically by `UiFormBuilderComponent` when the BlackBox\r\n   * service is available.\r\n   */\r\n  trackFormEvent(event: UiBlackboxFormEvent): void {\r\n    if (!this.initialised) return;\r\n\r\n    this.session.formEvents.push(event);\r\n    this.pushBufferEvent({ kind: 'formEvent', payload: event });\r\n  }\r\n\r\n  /**\r\n   * Track an intercepted HTTP call.\r\n   * Called by `UiBlackboxInterceptor`.\r\n   * @internal\r\n   */\r\n  trackHttpCall(call: UiBlackboxHttpCall): void {\r\n    if (!this.initialised) return;\r\n\r\n    this.session.calls.push(call);\r\n    this.pushBufferEvent({ kind: 'httpCall', payload: call });\r\n  }\r\n\r\n  // ─── Public API: Session access ────────────────────────────────────\r\n\r\n  /**\r\n   * Returns the current in-memory session (live, not yet flushed).\r\n   * Useful for debugging or real-time inspection.\r\n   */\r\n  getCurrentSession(): UiBlackboxSession {\r\n    return this.session;\r\n  }\r\n\r\n  /**\r\n   * Retrieve all sessions stored in IndexedDB (decompressed).\r\n   */\r\n  async getSessionHistory(): Promise<UiBlackboxSession[]> {\r\n    return this.storage.getAllSessions();\r\n  }\r\n\r\n  /**\r\n   * Retrieve sessions for the current device fingerprint.\r\n   */\r\n  async getSessionsForDevice(): Promise<UiBlackboxSession[]> {\r\n    const fp = await this.fingerprint.getFingerprint();\r\n    return this.storage.getSessionsByFingerprint(fp);\r\n  }\r\n\r\n  // ─── Public API: Export ────────────────────────────────────────────\r\n\r\n  /**\r\n   * Export all sessions as a downloadable JSONL Blob.\r\n   *\r\n   * @returns A Blob containing JSONL data (one session per line).\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const blob = await blackbox.exportSessions();\r\n   * const url = URL.createObjectURL(blob);\r\n   * const a = document.createElement('a');\r\n   * a.href = url;\r\n   * a.download = 'blackbox-sessions.jsonl';\r\n   * a.click();\r\n   * ```\r\n   */\r\n  async exportSessions(): Promise<Blob> {\r\n    // Flush current session first\r\n    await this.flush();\r\n    return this.storage.exportDump();\r\n  }\r\n\r\n  // ─── Public API: Lifecycle ─────────────────────────────────────────\r\n\r\n  /**\r\n   * Explicitly end the current session.\r\n   * Flushes all buffered events and marks the session as ended.\r\n   */\r\n  async endSession(): Promise<void> {\r\n    if (!this.initialised) return;\r\n    this.session.endedAt = Date.now();\r\n    await this.flush();\r\n  }\r\n\r\n  /**\r\n   * Clear all stored sessions from IndexedDB.\r\n   */\r\n  async clearHistory(): Promise<void> {\r\n    return this.storage.clearAll();\r\n  }\r\n\r\n  // ─── Buffer management ─────────────────────────────────────────────\r\n\r\n  /**\r\n   * Push an event into the centralised buffer.\r\n   * Triggers an immediate flush if the buffer exceeds the threshold.\r\n   * @internal\r\n   */\r\n  private pushBufferEvent(event: UiBlackboxBufferEvent): void {\r\n    this.buffer.push(event);\r\n    if (this.buffer.length >= this.config.flushThreshold) {\r\n      this.flush();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Flush buffered events to IndexedDB asynchronously.\r\n   * @internal\r\n   */\r\n  private async flush(): Promise<void> {\r\n    if (!this.initialised || this.buffer.length === 0) return;\r\n\r\n    // Drain buffer\r\n    const events = this.buffer.splice(0);\r\n\r\n    // Apply step events to the session\r\n    for (const event of events) {\r\n      if (event.kind === 'step') {\r\n        // Steps are already pushed in real-time; ensure they're in the session\r\n        if (!this.session.steps.includes(event.payload)) {\r\n          this.session.steps.push(event.payload);\r\n        }\r\n      }\r\n      // Actions, formEvents, httpCalls are already pushed in real-time\r\n      // to the in-memory session by trackAction/trackFormEvent/trackHttpCall\r\n    }\r\n\r\n    // Save the full session snapshot\r\n    try {\r\n      await this.storage.saveSession(this.session);\r\n    } catch (e) {\r\n      // storage error — re-enqueue events for next flush\r\n      console.warn('[UiBlackbox] Storage flush failed:', e);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Synchronous flush for `beforeunload`.\r\n   * Falls back to a best-effort approach since IndexedDB is async.\r\n   * @internal\r\n   */\r\n  private flushSync(): void {\r\n    if (!this.initialised) return;\r\n\r\n    this.session.endedAt = Date.now();\r\n\r\n    // Use sendBeacon-like approach: serialise session to localStorage\r\n    // as a fallback that can be recovered on next load.\r\n    // The proper IndexedDB flush is async and may not complete on unload.\r\n    try {\r\n      const key = `__ui_bb_pending_${this.session.sessionId}`;\r\n      const data = JSON.stringify(this.session);\r\n      localStorage.setItem(key, data);\r\n    } catch {\r\n      // Best effort — quota may be exceeded\r\n    }\r\n  }\r\n\r\n  // ─── Pending session recovery ──────────────────────────────────────\r\n\r\n  /**\r\n   * Recover sessions that were saved to localStorage during `beforeunload`\r\n   * and persist them to IndexedDB. Called on next service init.\r\n   * @internal\r\n   */\r\n  private async recoverPendingSessions(): Promise<void> {\r\n    if (!isPlatformBrowser(this.platformId)) return;\r\n\r\n    const prefix = '__ui_bb_pending_';\r\n    const keys: string[] = [];\r\n\r\n    for (let i = 0; i < localStorage.length; i++) {\r\n      const key = localStorage.key(i);\r\n      if (key?.startsWith(prefix)) {\r\n        keys.push(key);\r\n      }\r\n    }\r\n\r\n    for (const key of keys) {\r\n      try {\r\n        const data = localStorage.getItem(key);\r\n        if (data) {\r\n          const session: UiBlackboxSession = JSON.parse(data);\r\n          await this.storage.saveSession(session);\r\n        }\r\n        localStorage.removeItem(key);\r\n      } catch {\r\n        localStorage.removeItem(key);\r\n      }\r\n    }\r\n  }\r\n\r\n  // ─── Utilities ─────────────────────────────────────────────────────\r\n\r\n  /** Generate a UUID v4. */\r\n  private generateUuid(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return crypto.randomUUID();\r\n    }\r\n    // Fallback for older browsers\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\r\n      const r = (Math.random() * 16) | 0;\r\n      const v = c === 'x' ? r : (r & 0x3) | 0x8;\r\n      return v.toString(16);\r\n    });\r\n  }\r\n\r\n  // ─── Cleanup ───────────────────────────────────────────────────────\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n\r\n    if (this.flushTimerId !== null) {\r\n      clearInterval(this.flushTimerId);\r\n    }\r\n\r\n    if (this.beforeUnloadHandler) {\r\n      window.removeEventListener('beforeunload', this.beforeUnloadHandler);\r\n    }\r\n\r\n    // Final flush\r\n    this.flushSync();\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blackbox.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/blackbox/blackbox.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @module ng-ui-system/blackbox\r\n * Core BlackBox observability service — the main entry point for session\r\n * recording, event buffering, and export.\r\n *\r\n * Architecture:\r\n * - Root singleton (`providedIn: 'root'`)\r\n * - On first inject: generates fingerprint, creates session, subscribes to Router events\r\n * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB\r\n * - `window:beforeunload` triggers a final best-effort async flush\r\n */\r\n\r\nimport {\r\n  Injectable,\r\n  inject,\r\n  PLATFORM_ID,\r\n  OnDestroy,\r\n  NgZone,\r\n} from '@angular/core';\r\nimport { isPlatformBrowser } from '@angular/common';\r\nimport { Router, NavigationEnd } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\nimport { filter, takeUntil } from 'rxjs/operators';\r\n\r\nimport {\r\n  UiBlackboxConfig,\r\n  UiBlackboxFormTrackingConfig,\r\n  UiBlackboxSession,\r\n  UiBlackboxStep,\r\n  UiBlackboxAction,\r\n  UiBlackboxFormEvent,\r\n  UiBlackboxHttpCall,\r\n  UiBlackboxBufferEvent,\r\n  UI_BLACKBOX_DEFAULTS,\r\n} from './blackbox.types';\r\nimport { UiBlackboxFingerprintService } from './blackbox-fingerprint.service';\r\nimport { UiBlackboxStorageService } from './blackbox-storage.service';\r\n\r\n/**\r\n * Central BlackBox observability service.\r\n *\r\n * Records navigation, UI interactions, form events, and HTTP calls\r\n * into compressed sessions stored in IndexedDB.\r\n *\r\n * @usageNotes\r\n * The service activates automatically when injected. Provide it at root level\r\n * and it will start recording immediately.\r\n *\r\n * ```typescript\r\n * // app.config.ts — just importing the service is enough\r\n * import { UiBlackboxService } from '@gnggln/ng-ui-system';\r\n *\r\n * export const appConfig: ApplicationConfig = {\r\n *   providers: [\r\n *     // The service is providedIn: 'root', so it's auto-provided.\r\n *     // To force eager initialisation:\r\n *     { provide: APP_INITIALIZER, useFactory: () => () => inject(UiBlackboxService), multi: true },\r\n *   ],\r\n * };\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiBlackboxService implements OnDestroy {\r\n  private readonly platformId = inject(PLATFORM_ID);\r\n  private readonly router = inject(Router);\r\n  private readonly zone = inject(NgZone);\r\n  private readonly fingerprint = inject(UiBlackboxFingerprintService);\r\n  private readonly storage = inject(UiBlackboxStorageService);\r\n\r\n  private readonly destroy$ = new Subject<void>();\r\n  private config: UiBlackboxConfig = { ...UI_BLACKBOX_DEFAULTS };\r\n\r\n  // ─── Session state ─────────────────────────────────────────────────\r\n  private session!: UiBlackboxSession;\r\n  private currentStep: UiBlackboxStep | null = null;\r\n  private initialised = false;\r\n\r\n  // ─── Centralised event buffer ──────────────────────────────────────\r\n  private buffer: UiBlackboxBufferEvent[] = [];\r\n  private flushTimerId: ReturnType<typeof setInterval> | null = null;\r\n  private beforeUnloadHandler: (() => void) | null = null;\r\n\r\n  constructor() {\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      this.init();\r\n    }\r\n  }\r\n\r\n  // ─── Initialisation ────────────────────────────────────────────────\r\n\r\n  private async init(): Promise<void> {\r\n    // Generate session ID\r\n    const sessionId = this.generateUuid();\r\n    const fp = await this.fingerprint.getFingerprint();\r\n\r\n    this.session = {\r\n      sessionId,\r\n      fingerprint: fp,\r\n      startedAt: Date.now(),\r\n      userAgent: navigator.userAgent,\r\n      steps: [],\r\n      formEvents: [],\r\n      calls: [],\r\n    };\r\n\r\n    // Create initial step from current URL\r\n    this.currentStep = {\r\n      timestamp: Date.now(),\r\n      route: this.router.url,\r\n      actions: [],\r\n    };\r\n    this.session.steps.push(this.currentStep);\r\n\r\n    // Subscribe to router navigation\r\n    this.router.events\r\n      .pipe(\r\n        filter((e): e is NavigationEnd => e instanceof NavigationEnd),\r\n        takeUntil(this.destroy$),\r\n      )\r\n      .subscribe((event) => {\r\n        const previousRoute = this.currentStep?.route;\r\n        this.currentStep = {\r\n          timestamp: Date.now(),\r\n          route: event.urlAfterRedirects,\r\n          previousRoute,\r\n          actions: [],\r\n        };\r\n        this.pushBufferEvent({ kind: 'step', payload: this.currentStep });\r\n      });\r\n\r\n    // Setup periodic flush (outside Angular zone to avoid triggering CD)\r\n    this.zone.runOutsideAngular(() => {\r\n      this.flushTimerId = setInterval(\r\n        () => this.flush(),\r\n        this.config.flushIntervalMs,\r\n      );\r\n\r\n      // Best-effort flush on tab close (IndexedDB is async, no sync fallback)\r\n      this.beforeUnloadHandler = () => {\r\n        this.session.endedAt = Date.now();\r\n        void this.flush();\r\n      };\r\n      window.addEventListener('beforeunload', this.beforeUnloadHandler);\r\n    });\r\n\r\n    this.initialised = true;\r\n  }\r\n\r\n  // ─── Public API: Configuration ─────────────────────────────────────\r\n\r\n  /**\r\n   * Update the BlackBox configuration.\r\n   * Can be called at any time; changes take effect immediately.\r\n   */\r\n  configure(config: Partial<Omit<UiBlackboxConfig, 'formTracking'>> & { formTracking?: Partial<UiBlackboxFormTrackingConfig> }): void {\r\n    this.config = {\r\n      ...this.config,\r\n      ...config,\r\n      formTracking: {\r\n        ...this.config.formTracking,\r\n        ...(config.formTracking ?? {}),\r\n      },\r\n    };\r\n    this.storage.setMaxStorageMb(this.config.maxStorageMb);\r\n\r\n    // Restart flush timer with new interval\r\n    if (this.flushTimerId !== null) {\r\n      clearInterval(this.flushTimerId);\r\n      this.zone.runOutsideAngular(() => {\r\n        this.flushTimerId = setInterval(\r\n          () => this.flush(),\r\n          this.config.flushIntervalMs,\r\n        );\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Returns the current configuration (readonly snapshot). */\r\n  getConfig(): Readonly<UiBlackboxConfig> {\r\n    return { ...this.config };\r\n  }\r\n\r\n  // ─── Public API: Tracking ──────────────────────────────────────────\r\n\r\n  /**\r\n   * Manually track a UI action (click).\r\n   *\r\n   * Called automatically by `UiButtonAreaComponent` and the `[uiTrack]` directive.\r\n   * Can also be called programmatically for custom interactions.\r\n   *\r\n   * @param trackId - Identifier for the action (e.g. button id, link name).\r\n   * @param meta - Optional metadata: `tag`, `text`, `id` of the element.\r\n   */\r\n  trackAction(\r\n    trackId: string,\r\n    meta?: { tag?: string; text?: string; id?: string },\r\n  ): void {\r\n    if (!this.initialised) return;\r\n\r\n    const action: UiBlackboxAction = {\r\n      timestamp: Date.now(),\r\n      type: 'click',\r\n      target: {\r\n        tag: meta?.tag ?? 'unknown',\r\n        id: meta?.id,\r\n        trackId,\r\n        text: meta?.text?.substring(0, 50),\r\n      },\r\n    };\r\n\r\n    // Add to current step immediately (for in-memory session access)\r\n    this.currentStep?.actions.push(action);\r\n\r\n    // Also push to buffer for persistence\r\n    this.pushBufferEvent({\r\n      kind: 'action',\r\n      payload: { ...action, route: this.currentStep?.route ?? this.router.url },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Track a form interaction event.\r\n   *\r\n   * Called automatically by `UiFormBuilderComponent` when the BlackBox\r\n   * service is available.\r\n   */\r\n  trackFormEvent(event: UiBlackboxFormEvent): void {\r\n    if (!this.initialised) return;\r\n\r\n    this.session.formEvents.push(event);\r\n    this.pushBufferEvent({ kind: 'formEvent', payload: event });\r\n  }\r\n\r\n  /**\r\n   * Track an intercepted HTTP call.\r\n   * Called by `UiBlackboxInterceptor`.\r\n   * @internal\r\n   */\r\n  trackHttpCall(call: UiBlackboxHttpCall): void {\r\n    if (!this.initialised) return;\r\n\r\n    this.session.calls.push(call);\r\n    this.pushBufferEvent({ kind: 'httpCall', payload: call });\r\n  }\r\n\r\n  // ─── Public API: Session access ────────────────────────────────────\r\n\r\n  /**\r\n   * Returns the current in-memory session (live, not yet flushed).\r\n   * Useful for debugging or real-time inspection.\r\n   */\r\n  getCurrentSession(): UiBlackboxSession {\r\n    return this.session;\r\n  }\r\n\r\n  /**\r\n   * Retrieve all sessions stored in IndexedDB (decompressed).\r\n   */\r\n  async getSessionHistory(): Promise<UiBlackboxSession[]> {\r\n    return this.storage.getAllSessions();\r\n  }\r\n\r\n  /**\r\n   * Retrieve sessions for the current device fingerprint.\r\n   */\r\n  async getSessionsForDevice(): Promise<UiBlackboxSession[]> {\r\n    const fp = await this.fingerprint.getFingerprint();\r\n    return this.storage.getSessionsByFingerprint(fp);\r\n  }\r\n\r\n  // ─── Public API: Export ────────────────────────────────────────────\r\n\r\n  /**\r\n   * Export all sessions as a downloadable JSONL Blob.\r\n   *\r\n   * @returns A Blob containing JSONL data (one session per line).\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const blob = await blackbox.exportSessions();\r\n   * const url = URL.createObjectURL(blob);\r\n   * const a = document.createElement('a');\r\n   * a.href = url;\r\n   * a.download = 'blackbox-sessions.jsonl';\r\n   * a.click();\r\n   * ```\r\n   */\r\n  async exportSessions(): Promise<Blob> {\r\n    // Flush current session first\r\n    await this.flush();\r\n    return this.storage.exportDump();\r\n  }\r\n\r\n  // ─── Public API: Lifecycle ─────────────────────────────────────────\r\n\r\n  /**\r\n   * Explicitly end the current session.\r\n   * Flushes all buffered events and marks the session as ended.\r\n   */\r\n  async endSession(): Promise<void> {\r\n    if (!this.initialised) return;\r\n    this.session.endedAt = Date.now();\r\n    await this.flush();\r\n  }\r\n\r\n  /**\r\n   * Clear all stored sessions from IndexedDB.\r\n   */\r\n  async clearHistory(): Promise<void> {\r\n    return this.storage.clearAll();\r\n  }\r\n\r\n  // ─── Buffer management ─────────────────────────────────────────────\r\n\r\n  /**\r\n   * Push an event into the centralised buffer.\r\n   * Triggers an immediate flush if the buffer exceeds the threshold.\r\n   * @internal\r\n   */\r\n  private pushBufferEvent(event: UiBlackboxBufferEvent): void {\r\n    this.buffer.push(event);\r\n    if (this.buffer.length >= this.config.flushThreshold) {\r\n      this.flush();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Flush buffered events to IndexedDB asynchronously.\r\n   * @internal\r\n   */\r\n  private async flush(): Promise<void> {\r\n    if (!this.initialised || this.buffer.length === 0) return;\r\n\r\n    // Drain buffer\r\n    const events = this.buffer.splice(0);\r\n\r\n    // Apply step events to the session\r\n    for (const event of events) {\r\n      if (event.kind === 'step') {\r\n        // Steps are already pushed in real-time; ensure they're in the session\r\n        if (!this.session.steps.includes(event.payload)) {\r\n          this.session.steps.push(event.payload);\r\n        }\r\n      }\r\n      // Actions, formEvents, httpCalls are already pushed in real-time\r\n      // to the in-memory session by trackAction/trackFormEvent/trackHttpCall\r\n    }\r\n\r\n    // Save the full session snapshot\r\n    try {\r\n      await this.storage.saveSession(this.session);\r\n    } catch (e) {\r\n      // storage error — re-enqueue events for next flush\r\n      console.warn('[UiBlackbox] Storage flush failed:', e);\r\n    }\r\n  }\r\n\r\n  // ─── Utilities ─────────────────────────────────────────────────────\r\n\r\n  /** Generate a UUID v4. */\r\n  private generateUuid(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return crypto.randomUUID();\r\n    }\r\n    // Fallback for older browsers\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\r\n      const r = (Math.random() * 16) | 0;\r\n      const v = c === 'x' ? r : (r & 0x3) | 0x8;\r\n      return v.toString(16);\r\n    });\r\n  }\r\n\r\n  // ─── Cleanup ───────────────────────────────────────────────────────\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n\r\n    if (this.flushTimerId !== null) {\r\n      clearInterval(this.flushTimerId);\r\n    }\r\n\r\n    if (this.beforeUnloadHandler) {\r\n      window.removeEventListener('beforeunload', this.beforeUnloadHandler);\r\n    }\r\n\r\n    // Final flush\r\n    void this.flush();\r\n  }\r\n}\r\n"]}