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

package/esm2022/blackbox/lib/components/blackbox/blackbox-debugger.service.mjs

@@ -0,0 +1,51 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Servizio per aprire il debugger BlackBox in una modale fullscreen.
+ */
+import { Injectable, inject } from '@angular/core';
+import { UiModalService } from '../modal/index';
+import { UiBlackboxDebuggerComponent } from './blackbox-debugger.component';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per aprire il debugger BlackBox in una modale fullscreen
+ * tramite il UiModalService.
+ *
+ * @usageNotes
+ *
+ * ### Apertura base
+ * ```typescript
+ * const ref = this.debuggerService.open();
+ * ```
+ *
+ * ### Apertura con sessioni importate (JSONL)
+ * ```typescript
+ * this.debuggerService.open({ importedSessions: mySessions });
+ * ```
+ */
+export class UiBlackboxDebuggerService {
+    constructor() {
+        /** @internal Servizio modale per l'apertura. */
+        this.modalService = inject(UiModalService);
+    }
+    /**
+     * Apre il debugger in una modale fullscreen.
+     *
+     * @param config - Configurazione opzionale
+     * @returns Riferimento alla dialog per gestire chiusura
+     */
+    open(config) {
+        return this.modalService.open(UiBlackboxDebuggerComponent, {
+            size: 'fullscreen',
+            disableClose: false,
+            data: config ?? {},
+            panelClass: 'ui-blackbox-debugger-dialog',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxDebuggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxDebuggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxDebuggerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/blackbox/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"]}

package/esm2022/blackbox/lib/components/blackbox/blackbox-json-viewer.component.mjs

@@ -0,0 +1,66 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Componente modale per la visualizzazione di dati JSON nel debugger.
+ *
+ * Aperto da `UiBlackboxDebuggerComponent` tramite `UiModalService.open()`.
+ * Mostra il JSON formattato in un code block con syntax highlighting.
+ */
+import { Component, ChangeDetectionStrategy, Optional, Inject, } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { LucideAngularModule } from 'lucide-angular';
+import { UiModalComponent } from '../modal/index';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "lucide-angular";
+export class UiBlackboxJsonViewerComponent {
+    constructor(dialogRef, data) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.copied = false;
+        this.formattedJson = JSON.stringify(data?.json ?? {}, null, 2);
+    }
+    copyToClipboard() {
+        navigator.clipboard.writeText(this.formattedJson).then(() => {
+            this.copied = true;
+            setTimeout(() => { this.copied = false; }, 2000);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxJsonViewerComponent, deps: [{ token: i1.MatDialogRef, optional: true }, { token: MAT_DIALOG_DATA, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: UiBlackboxJsonViewerComponent, isStandalone: true, selector: "ui-blackbox-json-viewer", ngImport: i0, template: `
+    <ui-modal [config]="{ title: data.title || 'JSON', showCloseButton: true, hideFooter: true }">
+      <div class="json-viewer">
+        <div class="json-viewer__toolbar">
+          <button class="json-viewer__copy" (click)="copyToClipboard()">
+            <lucide-angular name="clipboard" [size]="12"></lucide-angular>
+            {{ copied ? 'Copiato!' : 'Copia' }}
+          </button>
+        </div>
+        <pre class="json-viewer__code"><code>{{ formattedJson }}</code></pre>
+      </div>
+    </ui-modal>
+  `, isInline: true, styles: [".json-viewer{display:flex;flex-direction:column;gap:8px;min-height:120px}.json-viewer__toolbar{display:flex;justify-content:flex-end}.json-viewer__copy{display:inline-flex;align-items:center;gap:4px;padding:4px 10px;border-radius:var(--ui-radius-sm, 4px);font-size:11px;font-weight:600;cursor:pointer;background:var(--ui-color-bg-subtle, #f5f5f5);color:var(--ui-color-text-secondary, #666);border:1px solid var(--ui-color-border, #e5e5e5);transition:all .12s;&:hover{background:var(--ui-color-surface-hover, #eee);color:var(--ui-color-primary, #3b82f6);border-color:var(--ui-color-primary, #3b82f6)}}.json-viewer__code{margin:0;padding:16px;background:var(--ui-color-bg-subtle, #1e1e2e);border:1px solid var(--ui-color-border, #e5e5e5);border-radius:var(--ui-radius-md, 8px);overflow:auto;max-height:70vh;font-family:var(--ui-font-family-mono, \"Fira Code\", monospace);font-size:12px;line-height:1.6;color:var(--ui-color-text, #1a1a1a);white-space:pre-wrap;word-break:break-word;tab-size:2}\n"], dependencies: [{ kind: "component", type: UiModalComponent, selector: "ui-modal", inputs: ["config"], outputs: ["closed"] }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i2.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxJsonViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-blackbox-json-viewer', standalone: true, imports: [UiModalComponent, LucideAngularModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <ui-modal [config]="{ title: data.title || 'JSON', showCloseButton: true, hideFooter: true }">
+      <div class="json-viewer">
+        <div class="json-viewer__toolbar">
+          <button class="json-viewer__copy" (click)="copyToClipboard()">
+            <lucide-angular name="clipboard" [size]="12"></lucide-angular>
+            {{ copied ? 'Copiato!' : 'Copia' }}
+          </button>
+        </div>
+        <pre class="json-viewer__code"><code>{{ formattedJson }}</code></pre>
+      </div>
+    </ui-modal>
+  `, styles: [".json-viewer{display:flex;flex-direction:column;gap:8px;min-height:120px}.json-viewer__toolbar{display:flex;justify-content:flex-end}.json-viewer__copy{display:inline-flex;align-items:center;gap:4px;padding:4px 10px;border-radius:var(--ui-radius-sm, 4px);font-size:11px;font-weight:600;cursor:pointer;background:var(--ui-color-bg-subtle, #f5f5f5);color:var(--ui-color-text-secondary, #666);border:1px solid var(--ui-color-border, #e5e5e5);transition:all .12s;&:hover{background:var(--ui-color-surface-hover, #eee);color:var(--ui-color-primary, #3b82f6);border-color:var(--ui-color-primary, #3b82f6)}}.json-viewer__code{margin:0;padding:16px;background:var(--ui-color-bg-subtle, #1e1e2e);border:1px solid var(--ui-color-border, #e5e5e5);border-radius:var(--ui-radius-md, 8px);overflow:auto;max-height:70vh;font-family:var(--ui-font-family-mono, \"Fira Code\", monospace);font-size:12px;line-height:1.6;color:var(--ui-color-text, #1a1a1a);white-space:pre-wrap;word-break:break-word;tab-size:2}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MatDialogRef, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/blackbox/lib/components/blackbox/blackbox-storage.service.mjs

@@ -0,0 +1,286 @@
+/**
+ * @module ng-ui-system/blackbox
+ * IndexedDB storage adapter for BlackBox sessions.
+ *
+ * Handles persistence, compression (via native CompressionStream gzip),
+ * quota enforcement, and JSONL export.
+ *
+ * Design notes:
+ * - DB name: `ui-blackbox`, object store: `sessions`
+ * - Each session is gzip-compressed before storage for both size
+ *   reduction and inherent obfuscation
+ * - Quota enforced by total stored size; oldest sessions are pruned first
+ */
+import { Injectable, inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { UI_BLACKBOX_DEFAULTS } from './blackbox.types';
+import * as i0 from "@angular/core";
+const DB_NAME = 'ui-blackbox';
+const DB_VERSION = 1;
+const STORE_NAME = 'sessions';
+/**
+ * Low-level IndexedDB adapter for reading/writing compressed BlackBox sessions.
+ *
+ * @usageNotes
+ * This service is used internally by `UiBlackboxService`.
+ * Consumers should interact with the higher-level `UiBlackboxService` API.
+ */
+export class UiBlackboxStorageService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.db = null;
+        this.maxStorageMb = UI_BLACKBOX_DEFAULTS.maxStorageMb;
+    }
+    // ─── Configuration ─────────────────────────────────────────────────
+    /** Update the storage quota from the parent service config. */
+    setMaxStorageMb(mb) {
+        this.maxStorageMb = mb;
+    }
+    // ─── Database lifecycle ────────────────────────────────────────────
+    /** Open (or create) the IndexedDB database. */
+    async openDb() {
+        if (this.db)
+            return this.db;
+        if (!isPlatformBrowser(this.platformId)) {
+            throw new Error('IndexedDB is not available in SSR');
+        }
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(DB_NAME, DB_VERSION);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    const store = db.createObjectStore(STORE_NAME, { keyPath: 'sessionId' });
+                    store.createIndex('fingerprint', 'fingerprint', { unique: false });
+                    store.createIndex('startedAt', 'startedAt', { unique: false });
+                }
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    // ─── Compression helpers ───────────────────────────────────────────
+    /** Compress a string to a gzip Uint8Array using native CompressionStream. */
+    async compress(data) {
+        const encoder = new TextEncoder();
+        const stream = new Blob([encoder.encode(data)])
+            .stream()
+            .pipeThrough(new CompressionStream('gzip'));
+        const reader = stream.getReader();
+        const chunks = [];
+        let done = false;
+        while (!done) {
+            const result = await reader.read();
+            done = result.done;
+            if (result.value) {
+                chunks.push(result.value);
+            }
+        }
+        // Merge chunks into a single ArrayBuffer-backed Uint8Array
+        const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+        const buffer = new ArrayBuffer(totalLength);
+        const merged = new Uint8Array(buffer);
+        let offset = 0;
+        for (const chunk of chunks) {
+            merged.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return merged;
+    }
+    /** Decompress a gzip Uint8Array back to a string. */
+    async decompress(data) {
+        const stream = new Blob([data])
+            .stream()
+            .pipeThrough(new DecompressionStream('gzip'));
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let result = '';
+        let done = false;
+        while (!done) {
+            const chunk = await reader.read();
+            done = chunk.done;
+            if (chunk.value) {
+                result += decoder.decode(chunk.value, { stream: !done });
+            }
+        }
+        return result;
+    }
+    // ─── CRUD ──────────────────────────────────────────────────────────
+    /**
+     * Persist a session to IndexedDB (gzip-compressed).
+     * Enforces quota after saving.
+     */
+    async saveSession(session) {
+        const db = await this.openDb();
+        const json = JSON.stringify(session);
+        const compressed = await this.compress(json);
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            const store = tx.objectStore(STORE_NAME);
+            // Store as { sessionId, fingerprint, startedAt, data: Uint8Array }
+            store.put({
+                sessionId: session.sessionId,
+                fingerprint: session.fingerprint,
+                startedAt: session.startedAt,
+                sizeBytes: compressed.byteLength,
+                data: compressed,
+            });
+            tx.oncomplete = () => {
+                this.enforceQuota().then(resolve).catch(resolve);
+            };
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    /**
+     * Read and decompress a single session by ID.
+     */
+    async getSession(sessionId) {
+        const db = await this.openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const store = tx.objectStore(STORE_NAME);
+            const req = store.get(sessionId);
+            req.onsuccess = async () => {
+                if (!req.result) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const json = await this.decompress(req.result.data);
+                    resolve(JSON.parse(json));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    /**
+     * Get all stored sessions (decompressed).
+     */
+    async getAllSessions() {
+        const db = await this.openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const store = tx.objectStore(STORE_NAME);
+            const req = store.getAll();
+            req.onsuccess = async () => {
+                try {
+                    const sessions = [];
+                    for (const record of req.result) {
+                        const json = await this.decompress(record.data);
+                        sessions.push(JSON.parse(json));
+                    }
+                    resolve(sessions);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    /**
+     * Get all sessions for a given fingerprint.
+     */
+    async getSessionsByFingerprint(fingerprint) {
+        const db = await this.openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const store = tx.objectStore(STORE_NAME);
+            const index = store.index('fingerprint');
+            const req = index.getAll(fingerprint);
+            req.onsuccess = async () => {
+                try {
+                    const sessions = [];
+                    for (const record of req.result) {
+                        const json = await this.decompress(record.data);
+                        sessions.push(JSON.parse(json));
+                    }
+                    resolve(sessions);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    /**
+     * Generate a downloadable JSONL Blob of all sessions.
+     * Each line is one JSON-serialised session (decompressed).
+     */
+    async exportDump() {
+        const sessions = await this.getAllSessions();
+        const lines = sessions.map((s) => JSON.stringify(s)).join('\n');
+        return new Blob([lines], { type: 'application/x-ndjson' });
+    }
+    /**
+     * Delete all stored sessions.
+     */
+    async clearAll() {
+        const db = await this.openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            const store = tx.objectStore(STORE_NAME);
+            store.clear();
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    // ─── Quota enforcement ─────────────────────────────────────────────
+    /**
+     * Prune oldest sessions until total stored size is under `maxStorageMb`.
+     * @internal
+     */
+    async enforceQuota() {
+        const db = await this.openDb();
+        const maxBytes = this.maxStorageMb * 1024 * 1024;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            const store = tx.objectStore(STORE_NAME);
+            const index = store.index('startedAt');
+            // Collect all records sorted by startedAt (ascending = oldest first)
+            const cursorReq = index.openCursor();
+            const records = [];
+            let totalSize = 0;
+            cursorReq.onsuccess = () => {
+                const cursor = cursorReq.result;
+                if (cursor) {
+                    const size = cursor.value.sizeBytes || 0;
+                    totalSize += size;
+                    records.push({ key: cursor.primaryKey, size });
+                    cursor.continue();
+                }
+                else {
+                    // Cursor exhausted — prune if over quota
+                    if (totalSize <= maxBytes) {
+                        resolve();
+                        return;
+                    }
+                    let freed = 0;
+                    const target = totalSize - maxBytes;
+                    for (const record of records) {
+                        if (freed >= target)
+                            break;
+                        store.delete(record.key);
+                        freed += record.size;
+                    }
+                    resolve();
+                }
+            };
+            cursorReq.onerror = () => reject(cursorReq.error);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiBlackboxStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blackbox-storage.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/blackbox/blackbox-storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @module ng-ui-system/blackbox\r\n * IndexedDB storage adapter for BlackBox sessions.\r\n *\r\n * Handles persistence, compression (via native CompressionStream gzip),\r\n * quota enforcement, and JSONL export.\r\n *\r\n * Design notes:\r\n * - DB name: `ui-blackbox`, object store: `sessions`\r\n * - Each session is gzip-compressed before storage for both size\r\n *   reduction and inherent obfuscation\r\n * - Quota enforced by total stored size; oldest sessions are pruned first\r\n */\r\n\r\nimport { Injectable, inject, PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformBrowser } from '@angular/common';\r\nimport type { UiBlackboxSession, UiBlackboxConfig } from './blackbox.types';\r\nimport { UI_BLACKBOX_DEFAULTS } from './blackbox.types';\r\n\r\nconst DB_NAME = 'ui-blackbox';\r\nconst DB_VERSION = 1;\r\nconst STORE_NAME = 'sessions';\r\n\r\n/**\r\n * Low-level IndexedDB adapter for reading/writing compressed BlackBox sessions.\r\n *\r\n * @usageNotes\r\n * This service is used internally by `UiBlackboxService`.\r\n * Consumers should interact with the higher-level `UiBlackboxService` API.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiBlackboxStorageService {\r\n  private readonly platformId = inject(PLATFORM_ID);\r\n  private db: IDBDatabase | null = null;\r\n  private maxStorageMb = UI_BLACKBOX_DEFAULTS.maxStorageMb;\r\n\r\n  // ─── Configuration ─────────────────────────────────────────────────\r\n\r\n  /** Update the storage quota from the parent service config. */\r\n  setMaxStorageMb(mb: number): void {\r\n    this.maxStorageMb = mb;\r\n  }\r\n\r\n  // ─── Database lifecycle ────────────────────────────────────────────\r\n\r\n  /** Open (or create) the IndexedDB database. */\r\n  private async openDb(): Promise<IDBDatabase> {\r\n    if (this.db) return this.db;\r\n    if (!isPlatformBrowser(this.platformId)) {\r\n      throw new Error('IndexedDB is not available in SSR');\r\n    }\r\n\r\n    return new Promise<IDBDatabase>((resolve, reject) => {\r\n      const request = indexedDB.open(DB_NAME, DB_VERSION);\r\n\r\n      request.onupgradeneeded = () => {\r\n        const db = request.result;\r\n        if (!db.objectStoreNames.contains(STORE_NAME)) {\r\n          const store = db.createObjectStore(STORE_NAME, { keyPath: 'sessionId' });\r\n          store.createIndex('fingerprint', 'fingerprint', { unique: false });\r\n          store.createIndex('startedAt', 'startedAt', { unique: false });\r\n        }\r\n      };\r\n\r\n      request.onsuccess = () => {\r\n        this.db = request.result;\r\n        resolve(this.db);\r\n      };\r\n\r\n      request.onerror = () => reject(request.error);\r\n    });\r\n  }\r\n\r\n  // ─── Compression helpers ───────────────────────────────────────────\r\n\r\n  /** Compress a string to a gzip Uint8Array using native CompressionStream. */\r\n  private async compress(data: string): Promise<Uint8Array> {\r\n    const encoder = new TextEncoder();\r\n    const stream = new Blob([encoder.encode(data) as BlobPart])\r\n      .stream()\r\n      .pipeThrough(new CompressionStream('gzip'));\r\n\r\n    const reader = stream.getReader();\r\n    const chunks: Uint8Array[] = [];\r\n    let done = false;\r\n\r\n    while (!done) {\r\n      const result = await reader.read();\r\n      done = result.done;\r\n      if (result.value) {\r\n        chunks.push(result.value);\r\n      }\r\n    }\r\n\r\n    // Merge chunks into a single ArrayBuffer-backed Uint8Array\r\n    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);\r\n    const buffer = new ArrayBuffer(totalLength);\r\n    const merged = new Uint8Array(buffer);\r\n    let offset = 0;\r\n    for (const chunk of chunks) {\r\n      merged.set(chunk, offset);\r\n      offset += chunk.length;\r\n    }\r\n    return merged;\r\n  }\r\n\r\n  /** Decompress a gzip Uint8Array back to a string. */\r\n  private async decompress(data: Uint8Array): Promise<string> {\r\n    const stream = new Blob([data as BlobPart])\r\n      .stream()\r\n      .pipeThrough(new DecompressionStream('gzip'));\r\n\r\n    const reader = stream.getReader();\r\n    const decoder = new TextDecoder();\r\n    let result = '';\r\n    let done = false;\r\n\r\n    while (!done) {\r\n      const chunk = await reader.read();\r\n      done = chunk.done;\r\n      if (chunk.value) {\r\n        result += decoder.decode(chunk.value, { stream: !done });\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  // ─── CRUD ──────────────────────────────────────────────────────────\r\n\r\n  /**\r\n   * Persist a session to IndexedDB (gzip-compressed).\r\n   * Enforces quota after saving.\r\n   */\r\n  async saveSession(session: UiBlackboxSession): Promise<void> {\r\n    const db = await this.openDb();\r\n    const json = JSON.stringify(session);\r\n    const compressed = await this.compress(json);\r\n\r\n    return new Promise<void>((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readwrite');\r\n      const store = tx.objectStore(STORE_NAME);\r\n\r\n      // Store as { sessionId, fingerprint, startedAt, data: Uint8Array }\r\n      store.put({\r\n        sessionId: session.sessionId,\r\n        fingerprint: session.fingerprint,\r\n        startedAt: session.startedAt,\r\n        sizeBytes: compressed.byteLength,\r\n        data: compressed,\r\n      });\r\n\r\n      tx.oncomplete = () => {\r\n        this.enforceQuota().then(resolve).catch(resolve);\r\n      };\r\n      tx.onerror = () => reject(tx.error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Read and decompress a single session by ID.\r\n   */\r\n  async getSession(sessionId: string): Promise<UiBlackboxSession | null> {\r\n    const db = await this.openDb();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readonly');\r\n      const store = tx.objectStore(STORE_NAME);\r\n      const req = store.get(sessionId);\r\n\r\n      req.onsuccess = async () => {\r\n        if (!req.result) {\r\n          resolve(null);\r\n          return;\r\n        }\r\n        try {\r\n          const json = await this.decompress(req.result.data);\r\n          resolve(JSON.parse(json));\r\n        } catch (e) {\r\n          reject(e);\r\n        }\r\n      };\r\n      req.onerror = () => reject(req.error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get all stored sessions (decompressed).\r\n   */\r\n  async getAllSessions(): Promise<UiBlackboxSession[]> {\r\n    const db = await this.openDb();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readonly');\r\n      const store = tx.objectStore(STORE_NAME);\r\n      const req = store.getAll();\r\n\r\n      req.onsuccess = async () => {\r\n        try {\r\n          const sessions: UiBlackboxSession[] = [];\r\n          for (const record of req.result) {\r\n            const json = await this.decompress(record.data);\r\n            sessions.push(JSON.parse(json));\r\n          }\r\n          resolve(sessions);\r\n        } catch (e) {\r\n          reject(e);\r\n        }\r\n      };\r\n      req.onerror = () => reject(req.error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get all sessions for a given fingerprint.\r\n   */\r\n  async getSessionsByFingerprint(fingerprint: string): Promise<UiBlackboxSession[]> {\r\n    const db = await this.openDb();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readonly');\r\n      const store = tx.objectStore(STORE_NAME);\r\n      const index = store.index('fingerprint');\r\n      const req = index.getAll(fingerprint);\r\n\r\n      req.onsuccess = async () => {\r\n        try {\r\n          const sessions: UiBlackboxSession[] = [];\r\n          for (const record of req.result) {\r\n            const json = await this.decompress(record.data);\r\n            sessions.push(JSON.parse(json));\r\n          }\r\n          resolve(sessions);\r\n        } catch (e) {\r\n          reject(e);\r\n        }\r\n      };\r\n      req.onerror = () => reject(req.error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Generate a downloadable JSONL Blob of all sessions.\r\n   * Each line is one JSON-serialised session (decompressed).\r\n   */\r\n  async exportDump(): Promise<Blob> {\r\n    const sessions = await this.getAllSessions();\r\n    const lines = sessions.map((s) => JSON.stringify(s)).join('\\n');\r\n    return new Blob([lines], { type: 'application/x-ndjson' });\r\n  }\r\n\r\n  /**\r\n   * Delete all stored sessions.\r\n   */\r\n  async clearAll(): Promise<void> {\r\n    const db = await this.openDb();\r\n\r\n    return new Promise<void>((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readwrite');\r\n      const store = tx.objectStore(STORE_NAME);\r\n      store.clear();\r\n      tx.oncomplete = () => resolve();\r\n      tx.onerror = () => reject(tx.error);\r\n    });\r\n  }\r\n\r\n  // ─── Quota enforcement ─────────────────────────────────────────────\r\n\r\n  /**\r\n   * Prune oldest sessions until total stored size is under `maxStorageMb`.\r\n   * @internal\r\n   */\r\n  async enforceQuota(): Promise<void> {\r\n    const db = await this.openDb();\r\n    const maxBytes = this.maxStorageMb * 1024 * 1024;\r\n\r\n    return new Promise<void>((resolve, reject) => {\r\n      const tx = db.transaction(STORE_NAME, 'readwrite');\r\n      const store = tx.objectStore(STORE_NAME);\r\n      const index = store.index('startedAt');\r\n\r\n      // Collect all records sorted by startedAt (ascending = oldest first)\r\n      const cursorReq = index.openCursor();\r\n      const records: { key: IDBValidKey; size: number }[] = [];\r\n      let totalSize = 0;\r\n\r\n      cursorReq.onsuccess = () => {\r\n        const cursor = cursorReq.result;\r\n        if (cursor) {\r\n          const size: number = cursor.value.sizeBytes || 0;\r\n          totalSize += size;\r\n          records.push({ key: cursor.primaryKey, size });\r\n          cursor.continue();\r\n        } else {\r\n          // Cursor exhausted — prune if over quota\r\n          if (totalSize <= maxBytes) {\r\n            resolve();\r\n            return;\r\n          }\r\n\r\n          let freed = 0;\r\n          const target = totalSize - maxBytes;\r\n          for (const record of records) {\r\n            if (freed >= target) break;\r\n            store.delete(record.key);\r\n            freed += record.size;\r\n          }\r\n          resolve();\r\n        }\r\n      };\r\n\r\n      cursorReq.onerror = () => reject(cursorReq.error);\r\n      tx.onerror = () => reject(tx.error);\r\n    });\r\n  }\r\n}\r\n"]}