@gnggln/ng-ui-system 1.0.0-alpha.0

package/esm2022/lib/components/crud-table/crud-table.types.mjs

@@ -0,0 +1,6 @@
+/**
+ * @module ng-ui-system/crud-table
+ * Tipi e interfacce per UiCrudTable.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud-table.types.js","sourceRoot":"","sources":["../../../../../../packages/ng-ui-system/src/lib/components/crud-table/crud-table.types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * @module ng-ui-system/crud-table\n * Tipi e interfacce per UiCrudTable.\n */\n\nimport { TemplateRef } from '@angular/core';\nimport { UiIconName } from '../../core/types';\nimport { UiFormSchema } from '../form-builder/types/schema.types';\n\n// Re-export per comodita del consumatore\nexport { UiIconName };\n\n// ─── Modalita CRUD ────────────────────────────────────────────────\n\n/**\n * Modalita operative della CRUD table.\n *\n * | Modalita    | Descrizione                                  |\n * |-------------|----------------------------------------------|\n * | `view`      | Visualizzazione tabella (stato iniziale)      |\n * | `insert`    | Inserimento nuovo elemento tramite form       |\n * | `edit`      | Modifica elemento esistente                   |\n * | `duplicate` | Duplicazione di un elemento                   |\n * | `readonly`  | Visualizzazione dettaglio in sola lettura      |\n */\nexport type UiCrudMode = 'view' | 'insert' | 'edit' | 'duplicate' | 'readonly';\n\n// ─── Colonna ──────────────────────────────────────────────────────\n\n/**\n * Definizione di una colonna della CRUD table.\n *\n * @usageNotes\n * ### Colonna testuale semplice\n * ```typescript\n * const col: UiCrudTableColumn = {\n *   key: 'name',\n *   header: 'Nome',\n *   width: '200px',\n * };\n * ```\n *\n * ### Colonna con template personalizzato\n * ```typescript\n * const col: UiCrudTableColumn = {\n *   key: 'status',\n *   header: 'Stato',\n *   template: myStatusTemplate,\n * };\n * ```\n */\nexport interface UiCrudTableColumn {\n  /** Chiave della proprieta nell'oggetto riga (usata per accedere al valore). */\n  key: string;\n\n  /** Testo dell'intestazione della colonna. */\n  header: string;\n\n  /**\n   * Template personalizzato per la cella.\n   * Il contesto fornisce: `$implicit` (riga), `column` (definizione), `index` (indice riga), `value` (valore cella).\n   */\n  template?: TemplateRef<any>;\n\n  /**\n   * Template personalizzato per l'intestazione.\n   * Il contesto fornisce: `$implicit` (colonna), `column` (definizione).\n   */\n  headerTemplate?: TemplateRef<any>;\n\n  /** Larghezza CSS della colonna (es. '120px', '20%'). */\n  width?: string;\n\n  /** Allineamento del testo nella colonna. @default 'left' */\n  align?: 'left' | 'center' | 'right';\n\n  /**\n   * Tronca il testo oltre maxLength caratteri con ellipsis e tooltip automatico.\n   * @default false\n   */\n  ellipsis?: boolean;\n\n  /**\n   * Numero massimo di caratteri prima del troncamento.\n   * Attivo solo quando `ellipsis` e `true`.\n   * @default 50\n   */\n  maxLength?: number;\n}\n\n// ─── Configurazione ───────────────────────────────────────────────\n\n/**\n * Configurazione completa della CRUD table.\n *\n * Controlla lo schema del form, le label dei pulsanti, i permessi\n * per azione (globali e per-riga) e i callback pre-apertura form.\n *\n * @usageNotes\n * ### Configurazione base\n * ```typescript\n * const config: UiCrudTableConfig = {\n *   formSchema: myFormSchema,\n *   tableLabel: 'Utenti',\n *   emptyMessage: 'Nessun utente presente',\n * };\n * ```\n *\n * ### Tabella con permessi granulari\n * ```typescript\n * const config: UiCrudTableConfig = {\n *   formSchema: mySchema,\n *   allowEdit: true,\n *   allowDelete: true,\n *   allowDuplicate: true,\n *   canEdit: (item) => item.status !== 'locked',\n *   canDelete: (item) => item.role !== 'admin',\n * };\n * ```\n */\nexport interface UiCrudTableConfig {\n  /** Schema per il form builder (inserimento/modifica). */\n  formSchema: UiFormSchema;\n\n  /** Etichetta della tabella (per accessibilita). */\n  tableLabel?: string;\n\n  /** Messaggio visualizzato quando non ci sono dati. @default 'Nessun elemento presente' */\n  emptyMessage?: string;\n\n  // ── Label pulsanti ──\n\n  /** Label del pulsante \"Aggiungi\". @default 'Aggiungi' */\n  addButtonLabel?: string;\n\n  /** Label del pulsante \"Salva\" (insert). @default 'Salva' */\n  saveButtonLabel?: string;\n\n  /** Label del pulsante \"Annulla\". @default 'Annulla' */\n  cancelButtonLabel?: string;\n\n  /** Label del pulsante \"Aggiorna\" (edit). @default 'Aggiorna' */\n  updateButtonLabel?: string;\n\n  /** Label del pulsante \"Duplica\" (duplicate). @default 'Duplica' */\n  duplicateButtonLabel?: string;\n\n  /** Messaggio per il dialogo di conferma eliminazione. */\n  deleteConfirmMessage?: string;\n\n  // ── Permessi globali ──\n\n  /**\n   * Abilita il pulsante \"Aggiungi\" in modalita view.\n   * @default true\n   */\n  allowAdd?: boolean;\n\n  /**\n   * Abilita la modifica degli elementi.\n   * @default true\n   */\n  allowEdit?: boolean;\n\n  /**\n   * Abilita l'eliminazione degli elementi.\n   * @default true\n   */\n  allowDelete?: boolean;\n\n  /**\n   * Abilita la duplicazione degli elementi.\n   * @default false\n   */\n  allowDuplicate?: boolean;\n\n  /**\n   * Abilita la visualizzazione in sola lettura.\n   * @default false\n   */\n  allowView?: boolean;\n\n  // ── Permessi per-riga (callback) ──\n\n  /**\n   * Determina se una specifica riga puo essere modificata.\n   * Se non specificata, usa `allowEdit` globale.\n   */\n  canEdit?: (item: any, readonly: boolean) => boolean;\n\n  /**\n   * Determina se una specifica riga puo essere eliminata.\n   * Se non specificata, usa `allowDelete` globale.\n   */\n  canDelete?: (item: any, readonly: boolean) => boolean;\n\n  /**\n   * Determina se una specifica riga puo essere duplicata.\n   * Se non specificata, usa `allowDuplicate` globale.\n   */\n  canDuplicate?: (item: any, readonly: boolean) => boolean;\n\n  /**\n   * Determina se una specifica riga puo essere visualizzata in readonly.\n   * Se non specificata, usa `allowView` globale.\n   */\n  canView?: (item: any) => boolean;\n\n  // ── Classi CSS per-riga ──\n\n  /**\n   * Restituisce classi CSS aggiuntive per una specifica riga.\n   * Utile per evidenziare righe in base allo stato.\n   */\n  getRowClass?: (item: any, index: number) => string | string[];\n\n  // ── Tooltip personalizzati ──\n\n  /** Tooltip personalizzato per l'azione Edit. */\n  getEditTooltip?: (item: any) => string;\n\n  /** Tooltip personalizzato per l'azione Delete. */\n  getDeleteTooltip?: (item: any) => string;\n\n  /** Tooltip personalizzato per l'azione Duplicate. */\n  getDuplicateTooltip?: (item: any) => string;\n\n  /** Tooltip personalizzato per l'azione View. */\n  getViewTooltip?: (item: any) => string;\n\n  // ── Tracking ──\n\n  /** Proprieta usata come chiave di tracking per le righe. @default 'id' */\n  trackByProperty?: string;\n\n  // ── Callback pre-apertura form ──\n\n  /**\n   * Callback invocato prima dell'apertura del form.\n   * Permette al componente genitore di modificare lo schema\n   * (es. disabilitare opzioni gia utilizzate).\n   */\n  onBeforeFormOpen?: (mode: UiCrudMode, editingItem: any, allData: any[]) => void;\n}\n\n// ─── Eventi ───────────────────────────────────────────────────────\n\n/**\n * Evento emesso alla modifica di un elemento.\n */\nexport interface UiCrudEditEvent<T = any> {\n  /** Elemento modificato. */\n  item: T;\n  /** Indice dell'elemento nella lista. */\n  index: number;\n  /** Dati originali prima della modifica. */\n  originalData: any;\n}\n\n/**\n * Evento emesso all'eliminazione di un elemento.\n */\nexport interface UiCrudDeleteEvent<T = any> {\n  /** Elemento eliminato. */\n  item: T;\n  /** Indice dell'elemento nella lista. */\n  index: number;\n}\n"]}

package/esm2022/lib/components/crud-table/index.mjs

@@ -0,0 +1,16 @@
+/**
+ * ng-ui-system — CRUD Table entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiCrudTableComponent,
+ *   UiCrudTableColumn,
+ *   UiCrudTableConfig,
+ *   UiCrudMode,
+ * } from 'ng-ui-system';
+ * ```
+ */
+// Componente
+export { UiCrudTableComponent } from './crud-table.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2NydWQtdGFibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7OztHQVlHO0FBRUgsYUFBYTtBQUNiLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIG5nLXVpLXN5c3RlbSDigJQgQ1JVRCBUYWJsZSBlbnRyeSBwb2ludC5cclxuICpcclxuICogQGV4YW1wbGVcclxuICogYGBgdHlwZXNjcmlwdFxyXG4gKiBpbXBvcnQge1xyXG4gKiAgIFVpQ3J1ZFRhYmxlQ29tcG9uZW50LFxyXG4gKiAgIFVpQ3J1ZFRhYmxlQ29sdW1uLFxyXG4gKiAgIFVpQ3J1ZFRhYmxlQ29uZmlnLFxyXG4gKiAgIFVpQ3J1ZE1vZGUsXHJcbiAqIH0gZnJvbSAnbmctdWktc3lzdGVtJztcclxuICogYGBgXHJcbiAqL1xyXG5cclxuLy8gQ29tcG9uZW50ZVxyXG5leHBvcnQgeyBVaUNydWRUYWJsZUNvbXBvbmVudCB9IGZyb20gJy4vY3J1ZC10YWJsZS5jb21wb25lbnQnO1xyXG5cclxuLy8gVGlwaVxyXG5leHBvcnQge1xyXG4gIFVpQ3J1ZFRhYmxlQ29sdW1uLFxyXG4gIFVpQ3J1ZFRhYmxlQ29uZmlnLFxyXG4gIFVpQ3J1ZE1vZGUsXHJcbiAgVWlDcnVkRWRpdEV2ZW50LFxyXG4gIFVpQ3J1ZERlbGV0ZUV2ZW50LFxyXG59IGZyb20gJy4vY3J1ZC10YWJsZS50eXBlcyc7XHJcbiJdfQ==

package/esm2022/lib/components/form-builder/adapters/it-date-adapter.mjs

@@ -0,0 +1,82 @@
+/**
+ * @module ng-ui-system/form-builder
+ * Adapter e formati per il datepicker italiano (DD/MM/YYYY).
+ */
+import { Injectable } from '@angular/core';
+import { NativeDateAdapter } from '@angular/material/core';
+import * as i0 from "@angular/core";
+/**
+ * Adapter personalizzato per il parsing delle date in formato italiano DD/MM/YYYY.
+ *
+ * Estende il NativeDateAdapter di Angular Material per gestire:
+ * - Parsing: converte stringhe DD/MM/YYYY in oggetti Date
+ * - Formattazione: visualizza le date nel formato italiano
+ * - Primo giorno della settimana: Lunedi (1)
+ */
+export class UiItalianDateAdapter extends NativeDateAdapter {
+    /**
+     * Il primo giorno della settimana e Lunedi (1).
+     */
+    getFirstDayOfWeek() {
+        return 1;
+    }
+    /**
+     * Parsing di una stringa di data in formato DD/MM/YYYY.
+     * Supporta sia il formato con separatore `/` che `-`.
+     */
+    parse(value) {
+        if (typeof value === 'string' && value.length > 0) {
+            // Gestisci formato DD/MM/YYYY o DD-MM-YYYY
+            const parts = value.split(/[\/\-]/);
+            if (parts.length === 3) {
+                const day = parseInt(parts[0], 10);
+                const month = parseInt(parts[1], 10) - 1; // Mesi 0-based
+                const year = parseInt(parts[2], 10);
+                if (!isNaN(day) && !isNaN(month) && !isNaN(year)) {
+                    // Validazione base
+                    if (day >= 1 && day <= 31 && month >= 0 && month <= 11 && year >= 1900 && year <= 2100) {
+                        return new Date(year, month, day);
+                    }
+                }
+            }
+        }
+        return super.parse(value);
+    }
+    /**
+     * Formatta una data in formato DD/MM/YYYY per la visualizzazione.
+     */
+    format(date, displayFormat) {
+        if (displayFormat === 'input') {
+            const day = date.getDate().toString().padStart(2, '0');
+            const month = (date.getMonth() + 1).toString().padStart(2, '0');
+            const year = date.getFullYear();
+            return `${day}/${month}/${year}`;
+        }
+        return date.toLocaleDateString('it-IT', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiItalianDateAdapter, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiItalianDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiItalianDateAdapter, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Formati data italiani per Angular Material.
+ * Configura il datepicker per usare DD/MM/YYYY.
+ */
+export const UI_IT_DATE_FORMATS = {
+    parse: {
+        dateInput: 'input',
+    },
+    display: {
+        dateInput: 'input',
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXQtZGF0ZS1hZGFwdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctdWktc3lzdGVtL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWJ1aWxkZXIvYWRhcHRlcnMvaXQtZGF0ZS1hZGFwdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGlCQUFpQixFQUFrQixNQUFNLHdCQUF3QixDQUFDOztBQUUzRTs7Ozs7OztHQU9HO0FBRUgsTUFBTSxPQUFPLG9CQUFxQixTQUFRLGlCQUFpQjtJQUN6RDs7T0FFRztJQUNNLGlCQUFpQjtRQUN4QixPQUFPLENBQUMsQ0FBQztJQUNYLENBQUM7SUFFRDs7O09BR0c7SUFDTSxLQUFLLENBQUMsS0FBVTtRQUN2QixJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQ2xELDJDQUEyQztZQUMzQyxNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ3BDLElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDdkIsTUFBTSxHQUFHLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDbkMsTUFBTSxLQUFLLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxlQUFlO2dCQUN6RCxNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO2dCQUVwQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7b0JBQ2pELG1CQUFtQjtvQkFDbkIsSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxFQUFFLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxLQUFLLElBQUksRUFBRSxJQUFJLElBQUksSUFBSSxJQUFJLElBQUksSUFBSSxJQUFJLElBQUksRUFBRSxDQUFDO3dCQUN2RixPQUFPLElBQUksSUFBSSxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUM7b0JBQ3BDLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzVCLENBQUM7SUFFRDs7T0FFRztJQUNNLE1BQU0sQ0FBQyxJQUFVLEVBQUUsYUFBcUI7UUFDL0MsSUFBSyxhQUFxQixLQUFLLE9BQU8sRUFBRSxDQUFDO1lBQ3ZDLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZELE1BQU0sS0FBSyxHQUFHLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUM7WUFDaEUsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ2hDLE9BQU8sR0FBRyxHQUFHLElBQUksS0FBSyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ25DLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLEVBQUU7WUFDdEMsSUFBSSxFQUFFLFNBQVM7WUFDZixLQUFLLEVBQUUsTUFBTTtZQUNiLEdBQUcsRUFBRSxTQUFTO1NBQ2YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzsrR0EvQ1Usb0JBQW9CO21IQUFwQixvQkFBb0I7OzRGQUFwQixvQkFBb0I7a0JBRGhDLFVBQVU7O0FBbURYOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFtQjtJQUNoRCxLQUFLLEVBQUU7UUFDTCxTQUFTLEVBQUUsT0FBTztLQUNuQjtJQUNELE9BQU8sRUFBRTtRQUNQLFNBQVMsRUFBRSxPQUFPO1FBQ2xCLGNBQWMsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRTtRQUNuRCxhQUFhLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRTtRQUNqRSxrQkFBa0IsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRTtLQUN2RDtDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQG1vZHVsZSBuZy11aS1zeXN0ZW0vZm9ybS1idWlsZGVyXHJcbiAqIEFkYXB0ZXIgZSBmb3JtYXRpIHBlciBpbCBkYXRlcGlja2VyIGl0YWxpYW5vIChERC9NTS9ZWVlZKS5cclxuICovXHJcblxyXG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE5hdGl2ZURhdGVBZGFwdGVyLCBNYXREYXRlRm9ybWF0cyB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIEFkYXB0ZXIgcGVyc29uYWxpenphdG8gcGVyIGlsIHBhcnNpbmcgZGVsbGUgZGF0ZSBpbiBmb3JtYXRvIGl0YWxpYW5vIEREL01NL1lZWVkuXHJcbiAqXHJcbiAqIEVzdGVuZGUgaWwgTmF0aXZlRGF0ZUFkYXB0ZXIgZGkgQW5ndWxhciBNYXRlcmlhbCBwZXIgZ2VzdGlyZTpcclxuICogLSBQYXJzaW5nOiBjb252ZXJ0ZSBzdHJpbmdoZSBERC9NTS9ZWVlZIGluIG9nZ2V0dGkgRGF0ZVxyXG4gKiAtIEZvcm1hdHRhemlvbmU6IHZpc3VhbGl6emEgbGUgZGF0ZSBuZWwgZm9ybWF0byBpdGFsaWFub1xyXG4gKiAtIFByaW1vIGdpb3JubyBkZWxsYSBzZXR0aW1hbmE6IEx1bmVkaSAoMSlcclxuICovXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIFVpSXRhbGlhbkRhdGVBZGFwdGVyIGV4dGVuZHMgTmF0aXZlRGF0ZUFkYXB0ZXIge1xyXG4gIC8qKlxyXG4gICAqIElsIHByaW1vIGdpb3JubyBkZWxsYSBzZXR0aW1hbmEgZSBMdW5lZGkgKDEpLlxyXG4gICAqL1xyXG4gIG92ZXJyaWRlIGdldEZpcnN0RGF5T2ZXZWVrKCk6IG51bWJlciB7XHJcbiAgICByZXR1cm4gMTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFBhcnNpbmcgZGkgdW5hIHN0cmluZ2EgZGkgZGF0YSBpbiBmb3JtYXRvIEREL01NL1lZWVkuXHJcbiAgICogU3VwcG9ydGEgc2lhIGlsIGZvcm1hdG8gY29uIHNlcGFyYXRvcmUgYC9gIGNoZSBgLWAuXHJcbiAgICovXHJcbiAgb3ZlcnJpZGUgcGFyc2UodmFsdWU6IGFueSk6IERhdGUgfCBudWxsIHtcclxuICAgIGlmICh0eXBlb2YgdmFsdWUgPT09ICdzdHJpbmcnICYmIHZhbHVlLmxlbmd0aCA+IDApIHtcclxuICAgICAgLy8gR2VzdGlzY2kgZm9ybWF0byBERC9NTS9ZWVlZIG8gREQtTU0tWVlZWVxyXG4gICAgICBjb25zdCBwYXJ0cyA9IHZhbHVlLnNwbGl0KC9bXFwvXFwtXS8pO1xyXG4gICAgICBpZiAocGFydHMubGVuZ3RoID09PSAzKSB7XHJcbiAgICAgICAgY29uc3QgZGF5ID0gcGFyc2VJbnQocGFydHNbMF0sIDEwKTtcclxuICAgICAgICBjb25zdCBtb250aCA9IHBhcnNlSW50KHBhcnRzWzFdLCAxMCkgLSAxOyAvLyBNZXNpIDAtYmFzZWRcclxuICAgICAgICBjb25zdCB5ZWFyID0gcGFyc2VJbnQocGFydHNbMl0sIDEwKTtcclxuXHJcbiAgICAgICAgaWYgKCFpc05hTihkYXkpICYmICFpc05hTihtb250aCkgJiYgIWlzTmFOKHllYXIpKSB7XHJcbiAgICAgICAgICAvLyBWYWxpZGF6aW9uZSBiYXNlXHJcbiAgICAgICAgICBpZiAoZGF5ID49IDEgJiYgZGF5IDw9IDMxICYmIG1vbnRoID49IDAgJiYgbW9udGggPD0gMTEgJiYgeWVhciA+PSAxOTAwICYmIHllYXIgPD0gMjEwMCkge1xyXG4gICAgICAgICAgICByZXR1cm4gbmV3IERhdGUoeWVhciwgbW9udGgsIGRheSk7XHJcbiAgICAgICAgICB9XHJcbiAgICAgICAgfVxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgICByZXR1cm4gc3VwZXIucGFyc2UodmFsdWUpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRm9ybWF0dGEgdW5hIGRhdGEgaW4gZm9ybWF0byBERC9NTS9ZWVlZIHBlciBsYSB2aXN1YWxpenphemlvbmUuXHJcbiAgICovXHJcbiAgb3ZlcnJpZGUgZm9ybWF0KGRhdGU6IERhdGUsIGRpc3BsYXlGb3JtYXQ6IG9iamVjdCk6IHN0cmluZyB7XHJcbiAgICBpZiAoKGRpc3BsYXlGb3JtYXQgYXMgYW55KSA9PT0gJ2lucHV0Jykge1xyXG4gICAgICBjb25zdCBkYXkgPSBkYXRlLmdldERhdGUoKS50b1N0cmluZygpLnBhZFN0YXJ0KDIsICcwJyk7XHJcbiAgICAgIGNvbnN0IG1vbnRoID0gKGRhdGUuZ2V0TW9udGgoKSArIDEpLnRvU3RyaW5nKCkucGFkU3RhcnQoMiwgJzAnKTtcclxuICAgICAgY29uc3QgeWVhciA9IGRhdGUuZ2V0RnVsbFllYXIoKTtcclxuICAgICAgcmV0dXJuIGAke2RheX0vJHttb250aH0vJHt5ZWFyfWA7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gZGF0ZS50b0xvY2FsZURhdGVTdHJpbmcoJ2l0LUlUJywge1xyXG4gICAgICB5ZWFyOiAnbnVtZXJpYycsXHJcbiAgICAgIG1vbnRoOiAnbG9uZycsXHJcbiAgICAgIGRheTogJ251bWVyaWMnLFxyXG4gICAgfSk7XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogRm9ybWF0aSBkYXRhIGl0YWxpYW5pIHBlciBBbmd1bGFyIE1hdGVyaWFsLlxyXG4gKiBDb25maWd1cmEgaWwgZGF0ZXBpY2tlciBwZXIgdXNhcmUgREQvTU0vWVlZWS5cclxuICovXHJcbmV4cG9ydCBjb25zdCBVSV9JVF9EQVRFX0ZPUk1BVFM6IE1hdERhdGVGb3JtYXRzID0ge1xyXG4gIHBhcnNlOiB7XHJcbiAgICBkYXRlSW5wdXQ6ICdpbnB1dCcsXHJcbiAgfSxcclxuICBkaXNwbGF5OiB7XHJcbiAgICBkYXRlSW5wdXQ6ICdpbnB1dCcsXHJcbiAgICBtb250aFllYXJMYWJlbDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnc2hvcnQnIH0sXHJcbiAgICBkYXRlQTExeUxhYmVsOiB7IHllYXI6ICdudW1lcmljJywgbW9udGg6ICdsb25nJywgZGF5OiAnbnVtZXJpYycgfSxcclxuICAgIG1vbnRoWWVhckExMXlMYWJlbDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnbG9uZycgfSxcclxuICB9LFxyXG59O1xyXG4iXX0=

package/esm2022/lib/components/form-builder/directives/currency-input.directive.mjs

@@ -0,0 +1,184 @@
+import { Directive, HostListener, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Direttiva per formattazione input valuta.
+ *
+ * Formatta il valore numerico con separatori italiani (1.234,56)
+ * e simbolo valuta opzionale. In fase di focus l'utente modifica
+ * il valore raw, al blur viene riformattato.
+ *
+ * Implementa `ControlValueAccessor` per integrazione con Reactive Forms.
+ *
+ * @selector [uiCurrencyInput]
+ *
+ * @example
+ * ```html
+ * <input uiCurrencyInput currencySymbol="EUR" [decimalPlaces]="2" />
+ * ```
+ */
+export class UiCurrencyInputDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        /** Simbolo valuta visualizzato. @default 'EUR' */
+        this.currencySymbol = 'EUR';
+        /** Numero di decimali. @default 2 */
+        this.decimalPlaces = 2;
+        this.rawValue = null;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.isFocused = false;
+    }
+    ngOnInit() {
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');
+    }
+    // ── ControlValueAccessor ──
+    writeValue(value) {
+        this.rawValue = value != null ? Number(value) : null;
+        if (!this.isFocused) {
+            this.displayFormatted();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);
+    }
+    // ── Gestione eventi ──
+    onFocus() {
+        this.isFocused = true;
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'left');
+        // Mostra valore raw per editing
+        if (this.rawValue != null) {
+            this.el.nativeElement.value = this.rawValue.toString().replace('.', ',');
+        }
+        else {
+            this.el.nativeElement.value = '';
+        }
+    }
+    onBlur() {
+        this.isFocused = false;
+        this.onTouched();
+        this.parseInput();
+        this.displayFormatted();
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');
+    }
+    onInput(value) {
+        // Permetti solo cifre, virgola e punto (come separatore decimale)
+        const sanitized = value.replace(/[^0-9,.\-]/g, '');
+        if (sanitized !== value) {
+            this.el.nativeElement.value = sanitized;
+        }
+    }
+    onKeyDown(event) {
+        const allowed = [
+            'Backspace',
+            'Delete',
+            'Tab',
+            'Escape',
+            'Enter',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'ArrowDown',
+            'Home',
+            'End',
+        ];
+        if (allowed.includes(event.key))
+            return;
+        // Permetti Ctrl+A, Ctrl+C, Ctrl+V, Ctrl+X
+        if (event.ctrlKey || event.metaKey)
+            return;
+        // Permetti cifre
+        if (/^\d$/.test(event.key))
+            return;
+        // Permetti virgola e punto (un solo separatore decimale)
+        if ((event.key === ',' || event.key === '.') && !this.el.nativeElement.value.includes(',')) {
+            return;
+        }
+        // Permetti segno meno solo all'inizio
+        if (event.key === '-' && this.el.nativeElement.selectionStart === 0) {
+            return;
+        }
+        event.preventDefault();
+    }
+    // ── Utilita interne ──
+    parseInput() {
+        const input = this.el.nativeElement.value.trim();
+        if (!input) {
+            this.rawValue = null;
+            this.onChange(null);
+            return;
+        }
+        // Normalizza: rimuovi punti migliaia, sostituisci virgola con punto
+        const normalized = input.replace(/\./g, '').replace(',', '.');
+        const num = parseFloat(normalized);
+        if (isNaN(num)) {
+            this.rawValue = null;
+            this.onChange(null);
+        }
+        else {
+            this.rawValue = num;
+            this.onChange(num);
+        }
+    }
+    /** Mostra il valore formattato con separatori italiani e simbolo. */
+    displayFormatted() {
+        if (this.rawValue == null) {
+            this.el.nativeElement.value = '';
+            return;
+        }
+        const formatted = this.formatItalian(this.rawValue, this.decimalPlaces);
+        this.el.nativeElement.value = this.currencySymbol ? `${formatted} ${this.currencySymbol}` : formatted;
+    }
+    /** Formattazione italiana: 1.234,56 */
+    formatItalian(value, decimals) {
+        const parts = value.toFixed(decimals).split('.');
+        const intPart = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, '.'); // NOSONAR - Used on controlled number strings from toFixed(), low ReDoS risk
+        return decimals > 0 ? `${intPart},${parts[1]}` : intPart;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiCurrencyInputDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: UiCurrencyInputDirective, isStandalone: true, selector: "[uiCurrencyInput]", inputs: { currencySymbol: "currencySymbol", decimalPlaces: "decimalPlaces" }, host: { listeners: { "focus": "onFocus()", "blur": "onBlur()", "input": "onInput($event.target.value)", "keydown": "onKeyDown($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => UiCurrencyInputDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiCurrencyInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uiCurrencyInput]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => UiCurrencyInputDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { currencySymbol: [{
+                type: Input
+            }], decimalPlaces: [{
+                type: Input
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event.target.value']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency-input.directive.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/directives/currency-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, OnInit, Renderer2, forwardRef } from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\n\r\n/**\r\n * Direttiva per formattazione input valuta.\r\n *\r\n * Formatta il valore numerico con separatori italiani (1.234,56)\r\n * e simbolo valuta opzionale. In fase di focus l'utente modifica\r\n * il valore raw, al blur viene riformattato.\r\n *\r\n * Implementa `ControlValueAccessor` per integrazione con Reactive Forms.\r\n *\r\n * @selector [uiCurrencyInput]\r\n *\r\n * @example\r\n * ```html\r\n * <input uiCurrencyInput currencySymbol=\"EUR\" [decimalPlaces]=\"2\" />\r\n * ```\r\n */\r\n@Directive({\r\n  selector: '[uiCurrencyInput]',\r\n  standalone: true,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => UiCurrencyInputDirective),\r\n      multi: true,\r\n    },\r\n  ],\r\n})\r\nexport class UiCurrencyInputDirective implements ControlValueAccessor, OnInit {\r\n  /** Simbolo valuta visualizzato. @default 'EUR' */\r\n  @Input() currencySymbol = 'EUR';\r\n\r\n  /** Numero di decimali. @default 2 */\r\n  @Input() decimalPlaces = 2;\r\n\r\n  private rawValue: number | null = null;\r\n  private onChange: (value: number | null) => void = () => {};\r\n  private onTouched: () => void = () => {};\r\n  private isFocused = false;\r\n\r\n  constructor(\r\n    private el: ElementRef<HTMLInputElement>,\r\n    private renderer: Renderer2,\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');\r\n  }\r\n\r\n  // ── ControlValueAccessor ──\r\n\r\n  writeValue(value: any): void {\r\n    this.rawValue = value != null ? Number(value) : null;\r\n    if (!this.isFocused) {\r\n      this.displayFormatted();\r\n    }\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);\r\n  }\r\n\r\n  // ── Gestione eventi ──\r\n\r\n  @HostListener('focus')\r\n  onFocus(): void {\r\n    this.isFocused = true;\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'left');\r\n    // Mostra valore raw per editing\r\n    if (this.rawValue != null) {\r\n      this.el.nativeElement.value = this.rawValue.toString().replace('.', ',');\r\n    } else {\r\n      this.el.nativeElement.value = '';\r\n    }\r\n  }\r\n\r\n  @HostListener('blur')\r\n  onBlur(): void {\r\n    this.isFocused = false;\r\n    this.onTouched();\r\n    this.parseInput();\r\n    this.displayFormatted();\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');\r\n  }\r\n\r\n  @HostListener('input', ['$event.target.value'])\r\n  onInput(value: string): void {\r\n    // Permetti solo cifre, virgola e punto (come separatore decimale)\r\n    const sanitized = value.replace(/[^0-9,.\\-]/g, '');\r\n    if (sanitized !== value) {\r\n      this.el.nativeElement.value = sanitized;\r\n    }\r\n  }\r\n\r\n  @HostListener('keydown', ['$event'])\r\n  onKeyDown(event: KeyboardEvent): void {\r\n    const allowed = [\r\n      'Backspace',\r\n      'Delete',\r\n      'Tab',\r\n      'Escape',\r\n      'Enter',\r\n      'ArrowLeft',\r\n      'ArrowRight',\r\n      'ArrowUp',\r\n      'ArrowDown',\r\n      'Home',\r\n      'End',\r\n    ];\r\n    if (allowed.includes(event.key)) return;\r\n\r\n    // Permetti Ctrl+A, Ctrl+C, Ctrl+V, Ctrl+X\r\n    if (event.ctrlKey || event.metaKey) return;\r\n\r\n    // Permetti cifre\r\n    if (/^\\d$/.test(event.key)) return;\r\n\r\n    // Permetti virgola e punto (un solo separatore decimale)\r\n    if ((event.key === ',' || event.key === '.') && !this.el.nativeElement.value.includes(',')) {\r\n      return;\r\n    }\r\n\r\n    // Permetti segno meno solo all'inizio\r\n    if (event.key === '-' && this.el.nativeElement.selectionStart === 0) {\r\n      return;\r\n    }\r\n\r\n    event.preventDefault();\r\n  }\r\n\r\n  // ── Utilita interne ──\r\n\r\n  private parseInput(): void {\r\n    const input = this.el.nativeElement.value.trim();\r\n    if (!input) {\r\n      this.rawValue = null;\r\n      this.onChange(null);\r\n      return;\r\n    }\r\n\r\n    // Normalizza: rimuovi punti migliaia, sostituisci virgola con punto\r\n    const normalized = input.replace(/\\./g, '').replace(',', '.');\r\n    const num = parseFloat(normalized);\r\n\r\n    if (isNaN(num)) {\r\n      this.rawValue = null;\r\n      this.onChange(null);\r\n    } else {\r\n      this.rawValue = num;\r\n      this.onChange(num);\r\n    }\r\n  }\r\n\r\n  /** Mostra il valore formattato con separatori italiani e simbolo. */\r\n  private displayFormatted(): void {\r\n    if (this.rawValue == null) {\r\n      this.el.nativeElement.value = '';\r\n      return;\r\n    }\r\n\r\n    const formatted = this.formatItalian(this.rawValue, this.decimalPlaces);\r\n    this.el.nativeElement.value = this.currencySymbol ? `${formatted} ${this.currencySymbol}` : formatted;\r\n  }\r\n\r\n  /** Formattazione italiana: 1.234,56 */\r\n  private formatItalian(value: number, decimals: number): string {\r\n    const parts = value.toFixed(decimals).split('.');\r\n    const intPart = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, '.'); // NOSONAR - Used on controlled number strings from toFixed(), low ReDoS risk\r\n    return decimals > 0 ? `${intPart},${parts[1]}` : intPart;\r\n  }\r\n}\r\n"]}