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

package/esm2022/form-builder-editor/lib/core/logging/logger.service.mjs

@@ -0,0 +1,295 @@
+/**
+ * @module ng-ui-system/core/logging
+ * Logger centralizzato con persistenza IndexedDB.
+ * Pattern omologato a ActionLoggerService del progetto Siform-PAL.
+ *
+ * @example
+ * const logger = inject(UiLoggerService);
+ * logger.logFormAction('form_submit', { schemaId: 'user-form', values: data });
+ * logger.logWizardAction('step_change', { from: 0, to: 1 });
+ */
+import { inject, Injectable, signal, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { UI_LOGGER_DEFAULT_TTL_MS, UI_LOGGER_IDB_NAME, UI_LOGGER_IDB_STORE, UI_LOGGER_IDB_VERSION, UI_LOGGER_MAX_ENTRIES, UI_LOGGER_LEVELS, } from './logger.config';
+import * as i0 from "@angular/core";
+/**
+ * Logger centralizzato per componenti ng-ui-system.
+ * Persiste su IndexedDB con cleanup automatico.
+ */
+export class UiLoggerService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.dbPromise = null;
+        /** Stato toggle runtime. */
+        this.enabled = signal(this.detectEnabled());
+        /** Configurazione runtime. */
+        this.config = {
+            enabled: this.detectEnabled(),
+            minLevel: 'debug',
+            ttlMs: UI_LOGGER_DEFAULT_TTL_MS,
+            maxEntries: UI_LOGGER_MAX_ENTRIES,
+        };
+    }
+    /** True se IndexedDB disponibile e siamo in browser. */
+    idbSupported() {
+        return isPlatformBrowser(this.platformId) && typeof indexedDB !== 'undefined';
+    }
+    /** Rileva se logging attivo (default: true in dev se non production). */
+    detectEnabled() {
+        if (!isPlatformBrowser(this.platformId))
+            return false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ng = window.ng;
+        const isDev = ng && typeof ng.probe === 'function';
+        return isDev;
+    }
+    /** Abilita/disabilita logging runtime. */
+    setEnabled(value) {
+        this.enabled.set(value);
+        this.config.enabled = value;
+    }
+    /** Configura il logger. */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        this.enabled.set(this.config.enabled);
+    }
+    //  Public API: generic log
+    /**
+     * Log generico con controllo enabled e livello.
+     */
+    log(category, level, action, payload, duration) {
+        if (!this.enabled())
+            return;
+        if (!this.shouldLogLevel(level))
+            return;
+        void this.persist(category, level, action, payload, duration);
+    }
+    /**
+     * Log azione form (submit, reset, valueChange, etc).
+     */
+    logFormAction(action, payload) {
+        this.log('form', 'info', action, payload);
+    }
+    /**
+     * Log azione wizard (stepChange, complete, validationFailed, etc).
+     */
+    logWizardAction(action, payload) {
+        this.log('wizard', 'info', action, payload);
+    }
+    /**
+     * Log errore.
+     */
+    logError(error, context) {
+        const payload = { ...context };
+        if (error instanceof Error) {
+            payload['message'] = error.message;
+            payload['stack'] = error.stack;
+        }
+        else {
+            payload['error'] = error;
+        }
+        this.log('error', 'error', 'exception', payload);
+    }
+    /**
+     * Log debug (solo se enabled e minLevel <= debug).
+     */
+    debug(category, action, payload) {
+        this.log(category, 'debug', action, payload);
+    }
+    //  IndexedDB persistence
+    async persist(category, level, action, payload, duration) {
+        if (!this.idbSupported())
+            return;
+        const entry = {
+            id: `${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+            category,
+            level,
+            action,
+            payload,
+            timestamp: Date.now(),
+            duration,
+            url: typeof window !== 'undefined' ? window.location.href : '',
+            userId: this.getUserId(),
+        };
+        try {
+            const db = await this.openDb();
+            const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');
+            tx.objectStore(UI_LOGGER_IDB_STORE).put(entry, entry.id);
+            // Debug visibile in dev mode
+            // eslint-disable-next-line no-console
+            if (this.enabled()) {
+                // eslint-disable-next-line no-console
+                console.log(`[UiLogger] ${entry.category}:${entry.action}`, entry.payload ?? '');
+            }
+            // Cleanup asincrono senza bloccare
+            void this.cleanupIfNeeded(db);
+        }
+        catch (e) {
+            // Silent fail: logging non deve rompere l'app
+            // eslint-disable-next-line no-console
+            console.warn('[UiLogger] Persist failed:', e);
+        }
+    }
+    /** Recupera userId da localStorage se disponibile. */
+    getUserId() {
+        if (typeof localStorage === 'undefined')
+            return undefined;
+        return localStorage.getItem('exLogin') ?? undefined;
+    }
+    /** Verifica se il livello deve essere loggato in base a minLevel. */
+    shouldLogLevel(level) {
+        const minIndex = UI_LOGGER_LEVELS.indexOf(this.config.minLevel);
+        const levelIndex = UI_LOGGER_LEVELS.indexOf(level);
+        return levelIndex >= minIndex;
+    }
+    //  Query API
+    /**
+     * Recupera log con filtri.
+     */
+    async query(filter = {}) {
+        if (!this.idbSupported())
+            return [];
+        const db = await this.openDb();
+        const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');
+        const store = tx.objectStore(UI_LOGGER_IDB_STORE);
+        const all = await new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+        return this.applyFilter(all, filter);
+    }
+    /**
+     * Riepilogo log per dashboard.
+     */
+    async summary() {
+        const all = await this.query();
+        const byCategory = { form: 0, wizard: 0, navigation: 0, system: 0, error: 0 };
+        const byLevel = { debug: 0, info: 0, warn: 0, error: 0 };
+        let oldest = Infinity;
+        let newest = 0;
+        for (const entry of all) {
+            byCategory[entry.category]++;
+            byLevel[entry.level]++;
+            if (entry.timestamp < oldest)
+                oldest = entry.timestamp;
+            if (entry.timestamp > newest)
+                newest = entry.timestamp;
+        }
+        return {
+            total: all.length,
+            byCategory,
+            byLevel,
+            oldest: oldest === Infinity ? 0 : oldest,
+            newest,
+        };
+    }
+    /**
+     * Cancella log più vecchi di TTL.
+     */
+    async purgeOld() {
+        if (!this.idbSupported())
+            return 0;
+        const cutoff = Date.now() - this.config.ttlMs;
+        const toDelete = [];
+        const db = await this.openDb();
+        const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');
+        const store = tx.objectStore(UI_LOGGER_IDB_STORE);
+        await new Promise((resolve, reject) => {
+            const cursor = store.openCursor();
+            cursor.onsuccess = (e) => {
+                const result = e.target.result;
+                if (!result) {
+                    resolve();
+                    return;
+                }
+                const entry = result.value;
+                if (entry.timestamp < cutoff) {
+                    toDelete.push(entry.id);
+                }
+                result.continue();
+            };
+            cursor.onerror = () => reject(cursor.error);
+        });
+        if (toDelete.length > 0) {
+            const delTx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');
+            for (const id of toDelete) {
+                delTx.objectStore(UI_LOGGER_IDB_STORE).delete(id);
+            }
+        }
+        return toDelete.length;
+    }
+    /**
+     * Cancella tutti i log.
+     */
+    async clear() {
+        if (!this.idbSupported())
+            return;
+        const db = await this.openDb();
+        const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');
+        await new Promise((resolve, reject) => {
+            const request = tx.objectStore(UI_LOGGER_IDB_STORE).clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    //  Internals
+    openDb() {
+        if (this.dbPromise)
+            return this.dbPromise;
+        this.dbPromise = new Promise((resolve, reject) => {
+            const req = indexedDB.open(UI_LOGGER_IDB_NAME, UI_LOGGER_IDB_VERSION);
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => resolve(req.result);
+            req.onupgradeneeded = (ev) => {
+                const db = ev.target.result;
+                if (!db.objectStoreNames.contains(UI_LOGGER_IDB_STORE)) {
+                    db.createObjectStore(UI_LOGGER_IDB_STORE);
+                }
+            };
+        });
+        return this.dbPromise;
+    }
+    async cleanupIfNeeded(db) {
+        const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');
+        const count = await new Promise((resolve, reject) => {
+            const req = tx.objectStore(UI_LOGGER_IDB_STORE).count();
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+        if (count > this.config.maxEntries) {
+            void this.purgeOld();
+        }
+    }
+    applyFilter(entries, filter) {
+        let result = entries;
+        if (filter.category) {
+            result = result.filter((e) => e.category === filter.category);
+        }
+        if (filter.level) {
+            result = result.filter((e) => e.level === filter.level);
+        }
+        if (filter.action) {
+            result = result.filter((e) => e.action.includes(filter.action));
+        }
+        if (filter.from) {
+            result = result.filter((e) => e.timestamp >= filter.from);
+        }
+        if (filter.to) {
+            result = result.filter((e) => e.timestamp <= filter.to);
+        }
+        // Ordina newest first
+        result = result.sort((a, b) => b.timestamp - a.timestamp);
+        if (filter.limit && filter.limit > 0) {
+            result = result.slice(0, filter.limit);
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLoggerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/core/logging/logger.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @module ng-ui-system/core/logging\r\n * Logger centralizzato con persistenza IndexedDB.\r\n * Pattern omologato a ActionLoggerService del progetto Siform-PAL.\r\n *\r\n * @example\r\n * const logger = inject(UiLoggerService);\r\n * logger.logFormAction('form_submit', { schemaId: 'user-form', values: data });\r\n * logger.logWizardAction('step_change', { from: 0, to: 1 });\r\n */\r\n\r\nimport { inject, Injectable, signal, PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformBrowser } from '@angular/common';\r\n\r\nimport type { UiLogCategory, UiLogEntry, UiLogFilter, UiLogLevel, UiLogSummary, UiLoggerConfig } from './logger.types';\r\nimport {\r\n  UI_LOGGER_DEFAULT_TTL_MS,\r\n  UI_LOGGER_IDB_NAME,\r\n  UI_LOGGER_IDB_STORE,\r\n  UI_LOGGER_IDB_VERSION,\r\n  UI_LOGGER_MAX_ENTRIES,\r\n  UI_LOGGER_LEVELS,\r\n} from './logger.config';\r\n\r\n/**\r\n * Logger centralizzato per componenti ng-ui-system.\r\n * Persiste su IndexedDB con cleanup automatico.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiLoggerService {\r\n  private readonly platformId = inject(PLATFORM_ID);\r\n  private dbPromise: Promise<IDBDatabase> | null = null;\r\n\r\n  /** Stato toggle runtime. */\r\n  readonly enabled = signal(this.detectEnabled());\r\n\r\n  /** Configurazione runtime. */\r\n  private config: UiLoggerConfig = {\r\n    enabled: this.detectEnabled(),\r\n    minLevel: 'debug',\r\n    ttlMs: UI_LOGGER_DEFAULT_TTL_MS,\r\n    maxEntries: UI_LOGGER_MAX_ENTRIES,\r\n  };\r\n\r\n  /** True se IndexedDB disponibile e siamo in browser. */\r\n  private idbSupported(): boolean {\r\n    return isPlatformBrowser(this.platformId) && typeof indexedDB !== 'undefined';\r\n  }\r\n\r\n  /** Rileva se logging attivo (default: true in dev se non production). */\r\n  private detectEnabled(): boolean {\r\n    if (!isPlatformBrowser(this.platformId)) return false;\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    const ng = (window as any).ng;\r\n    const isDev = ng && typeof ng.probe === 'function';\r\n    return isDev;\r\n  }\r\n\r\n  /** Abilita/disabilita logging runtime. */\r\n  setEnabled(value: boolean): void {\r\n    this.enabled.set(value);\r\n    this.config.enabled = value;\r\n  }\r\n\r\n  /** Configura il logger. */\r\n  configure(config: Partial<UiLoggerConfig>): void {\r\n    this.config = { ...this.config, ...config };\r\n    this.enabled.set(this.config.enabled);\r\n  }\r\n\r\n  //  Public API: generic log\r\n\r\n  /**\r\n   * Log generico con controllo enabled e livello.\r\n   */\r\n  log(\r\n    category: UiLogCategory,\r\n    level: UiLogLevel,\r\n    action: string,\r\n    payload?: Record<string, unknown>,\r\n    duration?: number\r\n  ): void {\r\n    if (!this.enabled()) return;\r\n    if (!this.shouldLogLevel(level)) return;\r\n    void this.persist(category, level, action, payload, duration);\r\n  }\r\n\r\n  /**\r\n   * Log azione form (submit, reset, valueChange, etc).\r\n   */\r\n  logFormAction(\r\n    action: 'init' | 'submit' | 'reset' | 'valueChange' | 'validationChange' | 'customEvent' | 'destroy',\r\n    payload: { schemaId: string;[key: string]: unknown }\r\n  ): void {\r\n    this.log('form', 'info', action, payload);\r\n  }\r\n\r\n  /**\r\n   * Log azione wizard (stepChange, complete, validationFailed, etc).\r\n   */\r\n  logWizardAction(\r\n    action: 'init' | 'stepChange' | 'stepComplete' | 'stepValidationFailed' | 'complete' | 'navigation' | 'save' | 'valueChange' | 'keyboardNavigation' | 'destroy',\r\n    payload: { wizardId?: string; step?: number;[key: string]: unknown }\r\n  ): void {\r\n    this.log('wizard', 'info', action, payload);\r\n  }\r\n\r\n  /**\r\n   * Log errore.\r\n   */\r\n  logError(error: Error | unknown, context?: Record<string, unknown>): void {\r\n    const payload: Record<string, unknown> = { ...context };\r\n    if (error instanceof Error) {\r\n      payload['message'] = error.message;\r\n      payload['stack'] = error.stack;\r\n    } else {\r\n      payload['error'] = error;\r\n    }\r\n    this.log('error', 'error', 'exception', payload);\r\n  }\r\n\r\n  /**\r\n   * Log debug (solo se enabled e minLevel <= debug).\r\n   */\r\n  debug(category: UiLogCategory, action: string, payload?: Record<string, unknown>): void {\r\n    this.log(category, 'debug', action, payload);\r\n  }\r\n\r\n  //  IndexedDB persistence\r\n\r\n  private async persist(\r\n    category: UiLogCategory,\r\n    level: UiLogLevel,\r\n    action: string,\r\n    payload?: Record<string, unknown>,\r\n    duration?: number\r\n  ): Promise<void> {\r\n    if (!this.idbSupported()) return;\r\n\r\n    const entry: UiLogEntry = {\r\n      id: `${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,\r\n      category,\r\n      level,\r\n      action,\r\n      payload,\r\n      timestamp: Date.now(),\r\n      duration,\r\n      url: typeof window !== 'undefined' ? window.location.href : '',\r\n      userId: this.getUserId(),\r\n    };\r\n\r\n    try {\r\n      const db = await this.openDb();\r\n      const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');\r\n      tx.objectStore(UI_LOGGER_IDB_STORE).put(entry, entry.id);\r\n\r\n      // Debug visibile in dev mode\r\n      // eslint-disable-next-line no-console\r\n      if (this.enabled()) {\r\n        // eslint-disable-next-line no-console\r\n        console.log(`[UiLogger] ${entry.category}:${entry.action}`, entry.payload ?? '');\r\n      }\r\n\r\n      // Cleanup asincrono senza bloccare\r\n      void this.cleanupIfNeeded(db);\r\n    } catch (e) {\r\n      // Silent fail: logging non deve rompere l'app\r\n      // eslint-disable-next-line no-console\r\n      console.warn('[UiLogger] Persist failed:', e);\r\n    }\r\n  }\r\n\r\n  /** Recupera userId da localStorage se disponibile. */\r\n  private getUserId(): string | undefined {\r\n    if (typeof localStorage === 'undefined') return undefined;\r\n    return localStorage.getItem('exLogin') ?? undefined;\r\n  }\r\n\r\n  /** Verifica se il livello deve essere loggato in base a minLevel. */\r\n  private shouldLogLevel(level: UiLogLevel): boolean {\r\n    const minIndex = UI_LOGGER_LEVELS.indexOf(this.config.minLevel);\r\n    const levelIndex = UI_LOGGER_LEVELS.indexOf(level);\r\n    return levelIndex >= minIndex;\r\n  }\r\n\r\n  //  Query API\r\n\r\n  /**\r\n   * Recupera log con filtri.\r\n   */\r\n  async query(filter: UiLogFilter = {}): Promise<UiLogEntry[]> {\r\n    if (!this.idbSupported()) return [];\r\n\r\n    const db = await this.openDb();\r\n    const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');\r\n    const store = tx.objectStore(UI_LOGGER_IDB_STORE);\r\n\r\n    const all: UiLogEntry[] = await new Promise((resolve, reject) => {\r\n      const request = store.getAll();\r\n      request.onsuccess = () => resolve(request.result as UiLogEntry[]);\r\n      request.onerror = () => reject(request.error);\r\n    });\r\n\r\n    return this.applyFilter(all, filter);\r\n  }\r\n\r\n  /**\r\n   * Riepilogo log per dashboard.\r\n   */\r\n  async summary(): Promise<UiLogSummary> {\r\n    const all = await this.query();\r\n\r\n    const byCategory = { form: 0, wizard: 0, navigation: 0, system: 0, error: 0 } as Record<UiLogCategory, number>;\r\n    const byLevel = { debug: 0, info: 0, warn: 0, error: 0 } as Record<UiLogLevel, number>;\r\n\r\n    let oldest = Infinity;\r\n    let newest = 0;\r\n\r\n    for (const entry of all) {\r\n      byCategory[entry.category]++;\r\n      byLevel[entry.level]++;\r\n      if (entry.timestamp < oldest) oldest = entry.timestamp;\r\n      if (entry.timestamp > newest) newest = entry.timestamp;\r\n    }\r\n\r\n    return {\r\n      total: all.length,\r\n      byCategory,\r\n      byLevel,\r\n      oldest: oldest === Infinity ? 0 : oldest,\r\n      newest,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Cancella log più vecchi di TTL.\r\n   */\r\n  async purgeOld(): Promise<number> {\r\n    if (!this.idbSupported()) return 0;\r\n\r\n    const cutoff = Date.now() - this.config.ttlMs;\r\n    const toDelete: string[] = [];\r\n\r\n    const db = await this.openDb();\r\n    const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');\r\n    const store = tx.objectStore(UI_LOGGER_IDB_STORE);\r\n\r\n    await new Promise<void>((resolve, reject) => {\r\n      const cursor = store.openCursor();\r\n      cursor.onsuccess = (e) => {\r\n        const result = (e.target as IDBRequest).result as IDBCursorWithValue | null;\r\n        if (!result) {\r\n          resolve();\r\n          return;\r\n        }\r\n        const entry = result.value as UiLogEntry;\r\n        if (entry.timestamp < cutoff) {\r\n          toDelete.push(entry.id);\r\n        }\r\n        result.continue();\r\n      };\r\n      cursor.onerror = () => reject(cursor.error);\r\n    });\r\n\r\n    if (toDelete.length > 0) {\r\n      const delTx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');\r\n      for (const id of toDelete) {\r\n        delTx.objectStore(UI_LOGGER_IDB_STORE).delete(id);\r\n      }\r\n    }\r\n\r\n    return toDelete.length;\r\n  }\r\n\r\n  /**\r\n   * Cancella tutti i log.\r\n   */\r\n  async clear(): Promise<void> {\r\n    if (!this.idbSupported()) return;\r\n\r\n    const db = await this.openDb();\r\n    const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readwrite');\r\n    await new Promise<void>((resolve, reject) => {\r\n      const request = tx.objectStore(UI_LOGGER_IDB_STORE).clear();\r\n      request.onsuccess = () => resolve();\r\n      request.onerror = () => reject(request.error);\r\n    });\r\n  }\r\n\r\n  //  Internals\r\n\r\n  private openDb(): Promise<IDBDatabase> {\r\n    if (this.dbPromise) return this.dbPromise;\r\n\r\n    this.dbPromise = new Promise((resolve, reject) => {\r\n      const req = indexedDB.open(UI_LOGGER_IDB_NAME, UI_LOGGER_IDB_VERSION);\r\n      req.onerror = () => reject(req.error);\r\n      req.onsuccess = () => resolve(req.result);\r\n      req.onupgradeneeded = (ev) => {\r\n        const db = (ev.target as IDBOpenDBRequest).result;\r\n        if (!db.objectStoreNames.contains(UI_LOGGER_IDB_STORE)) {\r\n          db.createObjectStore(UI_LOGGER_IDB_STORE);\r\n        }\r\n      };\r\n    });\r\n\r\n    return this.dbPromise;\r\n  }\r\n\r\n  private async cleanupIfNeeded(db: IDBDatabase): Promise<void> {\r\n    const tx = db.transaction(UI_LOGGER_IDB_STORE, 'readonly');\r\n    const count = await new Promise<number>((resolve, reject) => {\r\n      const req = tx.objectStore(UI_LOGGER_IDB_STORE).count();\r\n      req.onsuccess = () => resolve(req.result);\r\n      req.onerror = () => reject(req.error);\r\n    });\r\n\r\n    if (count > this.config.maxEntries) {\r\n      void this.purgeOld();\r\n    }\r\n  }\r\n\r\n  private applyFilter(entries: UiLogEntry[], filter: UiLogFilter): UiLogEntry[] {\r\n    let result = entries;\r\n\r\n    if (filter.category) {\r\n      result = result.filter((e) => e.category === filter.category);\r\n    }\r\n    if (filter.level) {\r\n      result = result.filter((e) => e.level === filter.level);\r\n    }\r\n    if (filter.action) {\r\n      result = result.filter((e) => e.action.includes(filter.action!));\r\n    }\r\n    if (filter.from) {\r\n      result = result.filter((e) => e.timestamp >= filter.from!);\r\n    }\r\n    if (filter.to) {\r\n      result = result.filter((e) => e.timestamp <= filter.to!);\r\n    }\r\n\r\n    // Ordina newest first\r\n    result = result.sort((a, b) => b.timestamp - a.timestamp);\r\n\r\n    if (filter.limit && filter.limit > 0) {\r\n      result = result.slice(0, filter.limit);\r\n    }\r\n\r\n    return result;\r\n  }\r\n}"]}

package/esm2022/form-builder-editor/lib/core/logging/logger.types.mjs

@@ -0,0 +1,7 @@
+/**
+ * @module ng-ui-system/core/logging
+ * Tipologie per il sistema di logging centralizzato della libreria.
+ * Pattern omologato a ActionLoggerService del progetto Siform-PAL.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form-builder-editor/lib/core/types/index.mjs

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