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

package/esm2022/lib/components/form-builder/services/location.service.mjs

@@ -0,0 +1,140 @@
+import { Injectable } from '@angular/core';
+import * as nazioniData from '../../../sources/nazioni.opt.json';
+import * as locationData from '../../../sources/location-data.opt.json';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la gestione dei dati geografici italiani
+ * da file JSON statici ottimizzati.
+ *
+ * Elimina la necessita di chiamate backend per nazioni,
+ * province, comuni e CAP. I dati vengono caricati in memoria
+ * al primo accesso e poi serviti dalla cache.
+ *
+ * @providedIn 'root'
+ *
+ * @example
+ * ```typescript
+ * const nazioni = await this.locationService.getNazioni();
+ * const province = await this.locationService.getProvince();
+ * const comuni = await this.locationService.getComuniByProvincia('015');
+ * const caps = await this.locationService.getCapList('015146');
+ * ```
+ */
+export class UiLocationService {
+    constructor() {
+        this.nazioniCache = new Map();
+        this.provinceCache = new Map();
+        this.comuniCache = new Map();
+        this.nazioniMap = nazioniData;
+        this.locationMap = locationData;
+        this.initializeCaches();
+    }
+    // ─── API pubblica ──────────────────────────────────────────────
+    /** Elenco completo delle nazioni (Italia prima). */
+    async getNazioni() {
+        const nazioni = Array.from(this.nazioniCache.values());
+        return { data: this.sortNazioniItaliaFirst(nazioni) };
+    }
+    /** Elenco completo delle province, ordinate alfabeticamente. */
+    async getProvince() {
+        const province = Array.from(this.provinceCache.values()).sort((a, b) => a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'));
+        return { content: province };
+    }
+    /** Elenco dei comuni per una specifica provincia. */
+    async getComuniByProvincia(provinciaId) {
+        const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];
+        const provincia = this.provinceCache.get(provinciaId);
+        if (!provincia)
+            return [];
+        return comuniMin
+            .map((c) => ({
+            codiceCatastale: c.x,
+            codiceComunePk: c.x,
+            comuneSoppresso: false,
+            nomeComune: c.d,
+            prov: provincia,
+            visibile: true,
+        }))
+            .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));
+    }
+    /** Elenco dei CAP per un comune. */
+    async getCapList(comuneId) {
+        for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {
+            const comune = comuni.find((c) => c.x === comuneId);
+            if (comune?.c) {
+                return Array.isArray(comune.c) ? comune.c : [comune.c];
+            }
+        }
+        return [];
+    }
+    /** Dati completi di una location (nazione, provincia o comune). */
+    async getLocationFullData(type, id, provinciaId) {
+        switch (type) {
+            case 'nazione':
+                return this.nazioniCache.get(id) ?? null;
+            case 'provincia':
+                return this.provinceCache.get(id) ?? null;
+            case 'comune':
+                if (!provinciaId)
+                    return this.comuniCache.get(id) ?? null;
+                const comuni = await this.getComuniByProvincia(provinciaId);
+                return comuni.find((c) => c.codiceComunePk === id) ?? null;
+            default:
+                return null;
+        }
+    }
+    // ─── Inizializzazione cache ────────────────────────────────────
+    initializeCaches() {
+        // Nazioni
+        for (const n of this.nazioniMap.nazioni) {
+            this.nazioniCache.set(n.x, {
+                codStatoPk: n.x,
+                codiceCatastale: n.x,
+                descrizione: n.d,
+            });
+        }
+        // Province
+        for (const p of this.locationMap.province) {
+            this.provinceCache.set(p.x, {
+                codiceProvinciaPk: p.x,
+                nomeProvincia: p.d,
+                siglaProvincia: p.x,
+                visibile: true,
+            });
+        }
+        // Comuni (con riferimento alla provincia)
+        for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {
+            const provincia = this.provinceCache.get(provinciaId);
+            if (!provincia)
+                continue;
+            for (const c of comuni) {
+                this.comuniCache.set(c.x, {
+                    codiceCatastale: c.x,
+                    codiceComunePk: c.x,
+                    comuneSoppresso: false,
+                    nomeComune: c.d,
+                    prov: provincia,
+                    visibile: true,
+                });
+            }
+        }
+    }
+    sortNazioniItaliaFirst(nazioni) {
+        return nazioni.sort((a, b) => {
+            const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';
+            const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';
+            if (aItalia && !bItalia)
+                return -1;
+            if (!aItalia && bItalia)
+                return 1;
+            return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/location.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as nazioniData from '../../../sources/nazioni.opt.json';\r\nimport * as locationData from '../../../sources/location-data.opt.json';\r\n\r\n// ─── Interfacce JSON ottimizzate ──────────────────────────────────\r\n\r\n/** Voce nazione nel JSON ottimizzato. */\r\nexport interface MinifiedNazioneOption {\r\n  /** Codice nazione (es. `'ITA'`). */\r\n  x: string;\r\n  /** Descrizione (es. `'Italia'`). */\r\n  d: string;\r\n}\r\n\r\n/** Voce provincia/comune nel JSON ottimizzato. */\r\nexport interface MinifiedSelectOption {\r\n  /** Codice (provincia o comune). */\r\n  x: string;\r\n  /** Descrizione. */\r\n  d: string;\r\n  /** CAP singolo o multipli. */\r\n  c?: string | string[];\r\n}\r\n\r\ninterface MinifiedLocationMap {\r\n  province: MinifiedSelectOption[];\r\n  comuniPerProvincia: Record<string, MinifiedSelectOption[]>;\r\n}\r\n\r\ninterface MinifiedNazioniMap {\r\n  nazioni: MinifiedNazioneOption[];\r\n}\r\n\r\n// ─── Interfacce pubbliche (formato legacy compatibile) ───────────\r\n\r\n/** Nazione. */\r\nexport interface UiNazione {\r\n  codStatoPk: string;\r\n  codiceCatastale: string;\r\n  descrizione: string;\r\n}\r\n\r\n/** Provincia. */\r\nexport interface UiProvincia {\r\n  codiceProvinciaPk: string;\r\n  nomeProvincia: string;\r\n  siglaProvincia: string;\r\n  visibile: boolean;\r\n}\r\n\r\n/** Comune. */\r\nexport interface UiComune {\r\n  codiceCatastale: string;\r\n  codiceComunePk: string;\r\n  comuneSoppresso: boolean;\r\n  nomeComune: string;\r\n  prov: UiProvincia;\r\n  visibile: boolean;\r\n}\r\n\r\n/**\r\n * Servizio per la gestione dei dati geografici italiani\r\n * da file JSON statici ottimizzati.\r\n *\r\n * Elimina la necessita di chiamate backend per nazioni,\r\n * province, comuni e CAP. I dati vengono caricati in memoria\r\n * al primo accesso e poi serviti dalla cache.\r\n *\r\n * @providedIn 'root'\r\n *\r\n * @example\r\n * ```typescript\r\n * const nazioni = await this.locationService.getNazioni();\r\n * const province = await this.locationService.getProvince();\r\n * const comuni = await this.locationService.getComuniByProvincia('015');\r\n * const caps = await this.locationService.getCapList('015146');\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiLocationService {\r\n  private readonly nazioniMap: MinifiedNazioniMap;\r\n  private readonly locationMap: MinifiedLocationMap;\r\n  private readonly nazioniCache = new Map<string, UiNazione>();\r\n  private readonly provinceCache = new Map<string, UiProvincia>();\r\n  private readonly comuniCache = new Map<string, UiComune>();\r\n\r\n  constructor() {\r\n    this.nazioniMap = nazioniData as MinifiedNazioniMap;\r\n    this.locationMap = locationData as any;\r\n    this.initializeCaches();\r\n  }\r\n\r\n  // ─── API pubblica ──────────────────────────────────────────────\r\n\r\n  /** Elenco completo delle nazioni (Italia prima). */\r\n  async getNazioni(): Promise<{ data: UiNazione[] }> {\r\n    const nazioni = Array.from(this.nazioniCache.values());\r\n    return { data: this.sortNazioniItaliaFirst(nazioni) };\r\n  }\r\n\r\n  /** Elenco completo delle province, ordinate alfabeticamente. */\r\n  async getProvince(): Promise<{ content: UiProvincia[] }> {\r\n    const province = Array.from(this.provinceCache.values()).sort((a, b) =>\r\n      a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'),\r\n    );\r\n    return { content: province };\r\n  }\r\n\r\n  /** Elenco dei comuni per una specifica provincia. */\r\n  async getComuniByProvincia(provinciaId: string): Promise<UiComune[]> {\r\n    const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];\r\n    const provincia = this.provinceCache.get(provinciaId);\r\n    if (!provincia) return [];\r\n\r\n    return comuniMin\r\n      .map((c) => ({\r\n        codiceCatastale: c.x,\r\n        codiceComunePk: c.x,\r\n        comuneSoppresso: false,\r\n        nomeComune: c.d,\r\n        prov: provincia,\r\n        visibile: true,\r\n      }))\r\n      .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));\r\n  }\r\n\r\n  /** Elenco dei CAP per un comune. */\r\n  async getCapList(comuneId: string): Promise<string[]> {\r\n    for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {\r\n      const comune = comuni.find((c) => c.x === comuneId);\r\n      if (comune?.c) {\r\n        return Array.isArray(comune.c) ? comune.c : [comune.c];\r\n      }\r\n    }\r\n    return [];\r\n  }\r\n\r\n  /** Dati completi di una location (nazione, provincia o comune). */\r\n  async getLocationFullData(\r\n    type: 'nazione' | 'provincia' | 'comune',\r\n    id: string,\r\n    provinciaId?: string,\r\n  ): Promise<UiNazione | UiProvincia | UiComune | null> {\r\n    switch (type) {\r\n      case 'nazione':\r\n        return this.nazioniCache.get(id) ?? null;\r\n      case 'provincia':\r\n        return this.provinceCache.get(id) ?? null;\r\n      case 'comune':\r\n        if (!provinciaId) return this.comuniCache.get(id) ?? null;\r\n        const comuni = await this.getComuniByProvincia(provinciaId);\r\n        return comuni.find((c) => c.codiceComunePk === id) ?? null;\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  // ─── Inizializzazione cache ────────────────────────────────────\r\n\r\n  private initializeCaches(): void {\r\n    // Nazioni\r\n    for (const n of this.nazioniMap.nazioni) {\r\n      this.nazioniCache.set(n.x, {\r\n        codStatoPk: n.x,\r\n        codiceCatastale: n.x,\r\n        descrizione: n.d,\r\n      });\r\n    }\r\n\r\n    // Province\r\n    for (const p of this.locationMap.province) {\r\n      this.provinceCache.set(p.x, {\r\n        codiceProvinciaPk: p.x,\r\n        nomeProvincia: p.d,\r\n        siglaProvincia: p.x,\r\n        visibile: true,\r\n      });\r\n    }\r\n\r\n    // Comuni (con riferimento alla provincia)\r\n    for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {\r\n      const provincia = this.provinceCache.get(provinciaId);\r\n      if (!provincia) continue;\r\n      for (const c of comuni) {\r\n        this.comuniCache.set(c.x, {\r\n          codiceCatastale: c.x,\r\n          codiceComunePk: c.x,\r\n          comuneSoppresso: false,\r\n          nomeComune: c.d,\r\n          prov: provincia,\r\n          visibile: true,\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private sortNazioniItaliaFirst(nazioni: UiNazione[]): UiNazione[] {\r\n    return nazioni.sort((a, b) => {\r\n      const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';\r\n      const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';\r\n      if (aItalia && !bItalia) return -1;\r\n      if (!aItalia && bItalia) return 1;\r\n      return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/form-builder/services/wizard-sync.service.mjs

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la sincronizzazione dello stato del wizard
+ * tra istanze multiple (es. header esterno e form wizard).
+ *
+ * Utilizza BehaviorSubject per mantenere lo stato corrente
+ * e notificare i sottoscrittori in tempo reale.
+ *
+ * @providedIn 'root'
+ *
+ * @example
+ * ```typescript
+ * // Nel componente header esterno
+ * this.wizardSync.getWizardState$('my-wizard')
+ *   .subscribe(data => {
+ *     this.currentStep = data?.wizardState.currentStep;
+ *     this.totalSteps = data?.wizardState.totalSteps;
+ *   });
+ *
+ * // Navigazione da header esterno
+ * this.wizardSync.navigateToStep('my-wizard', 2);
+ * ```
+ */
+export class UiWizardSyncService {
+    constructor() {
+        this.instances = new Map();
+    }
+    /** Registra un nuovo wizard o aggiorna uno esistente. */
+    registerWizard(wizardId, data) {
+        if (!this.instances.has(wizardId)) {
+            this.instances.set(wizardId, new BehaviorSubject(null));
+        }
+        this.instances.get(wizardId).next(data);
+    }
+    /** Ottiene un observable per monitorare lo stato di un wizard. */
+    getWizardState$(wizardId) {
+        if (!this.instances.has(wizardId)) {
+            this.instances.set(wizardId, new BehaviorSubject(null));
+        }
+        return this.instances.get(wizardId).asObservable();
+    }
+    /** Ottiene lo stato corrente (snapshot). */
+    getCurrentWizardState(wizardId) {
+        return this.instances.get(wizardId)?.value ?? null;
+    }
+    /** Rimuove un wizard dal registro (cleanup su destroy). */
+    unregisterWizard(wizardId) {
+        const subject = this.instances.get(wizardId);
+        if (subject) {
+            subject.complete();
+            this.instances.delete(wizardId);
+        }
+    }
+    /** Aggiorna parzialmente lo stato del wizard. */
+    updateWizardState(wizardId, partial) {
+        const subject = this.instances.get(wizardId);
+        const current = subject?.value;
+        if (current) {
+            subject.next({
+                ...current,
+                wizardState: { ...current.wizardState, ...partial },
+            });
+        }
+    }
+    /** Emette un evento di navigazione verso uno step specifico. */
+    navigateToStep(wizardId, stepIndex) {
+        const current = this.getCurrentWizardState(wizardId);
+        if (current) {
+            this.updateWizardState(wizardId, {
+                currentStep: stepIndex,
+                visitedSteps: new Set([...current.wizardState.visitedSteps, stepIndex]),
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardSyncService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardSyncService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardSyncService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-builder/sub-components/error-summary/form-error-summary.component.mjs

@@ -0,0 +1,161 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { LucideAngularModule } from 'lucide-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "lucide-angular";
+/**
+ * Componente per il riepilogo errori del form.
+ *
+ * Mostra un indicatore con il conteggio degli errori e un dropdown
+ * con il dettaglio per campo. Click su un errore emette `fieldClick`
+ * per consentire lo scroll-to-field con highlight nel form builder.
+ *
+ * @selector ui-form-error-summary
+ */
+export class UiFormErrorSummaryComponent {
+    constructor() {
+        /** Lista di errori dettagliati per campo. */
+        this.errors = [];
+        /** Conteggio totale degli errori (somma di tutti i messaggi). */
+        this.totalErrorCount = 0;
+        /** Emesso quando l'utente clicca su un errore per navigare al campo. */
+        this.fieldClick = new EventEmitter();
+        /** @internal Stato del dropdown. */
+        this.showDropdown = false;
+    }
+    /** Conteggio da visualizzare: usa totalErrorCount se fornito, altrimenti conta dai dettagli. */
+    get displayCount() {
+        return this.totalErrorCount > 0 ? this.totalErrorCount : this.errors.reduce((sum, d) => sum + d.errors.length, 0);
+    }
+    /** @internal Gestione click su errore. */
+    onFieldClick(fieldKey) {
+        this.showDropdown = false;
+        this.fieldClick.emit(fieldKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormErrorSummaryComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiFormErrorSummaryComponent, isStandalone: true, selector: "ui-form-error-summary", inputs: { errors: "errors", totalErrorCount: "totalErrorCount" }, outputs: { fieldClick: "fieldClick" }, ngImport: i0, template: `
+    @if (errors.length > 0) {
+      <div
+        class="ui-form-error-summary"
+        (mouseenter)="showDropdown = true"
+        (mouseleave)="showDropdown = false"
+      >
+        <!-- Indicatore errori con icona e messaggio -->
+        <div class="ui-form-error-summary__heading"
+          (click)="showDropdown = !showDropdown"
+          role="button"
+          tabindex="0"
+          [attr.aria-label]="displayCount + ' errori nel form'"
+          (keydown.enter)="showDropdown = !showDropdown"
+          (keydown.space)="showDropdown = !showDropdown; $event.preventDefault()"
+        >
+          <lucide-icon name="alert-circle" [size]="20" class="ui-form-error-summary__icon" aria-hidden="true" />
+          <p class="ui-form-error-summary__text">
+            Sono presenti <strong>{{ displayCount }}</strong>
+            {{ displayCount === 1 ? 'errore' : 'errori' }} nel form.
+          </p>
+        </div>
+
+        <!-- Dropdown dettaglio -->
+        <div
+          class="ui-form-error-summary__dropdown"
+          [class.ui-form-error-summary__dropdown--visible]="showDropdown"
+          role="list"
+          aria-label="Elenco errori del form"
+        >
+          <div class="ui-form-error-summary__dropdown-content">
+            <h4 class="ui-form-error-summary__dropdown-title">Dettagli errori:</h4>
+            <ul class="ui-form-error-summary__list">
+              @for (detail of errors; track detail.fieldKey) {
+                <li
+                  class="ui-form-error-summary__item"
+                  role="listitem"
+                  (click)="onFieldClick(detail.fieldKey)"
+                  tabindex="0"
+                  (keydown.enter)="onFieldClick(detail.fieldKey)"
+                >
+                  <div class="ui-form-error-summary__field-name">
+                    <lucide-icon name="arrow-right" [size]="14" class="ui-form-error-summary__arrow" aria-hidden="true" />
+                    {{ detail.fieldLabel }}
+                  </div>
+                  <div class="ui-form-error-summary__messages">
+                    @for (err of detail.errors; track $index; let last = $last) {
+                      <span>{{ err }}@if (!last) {, }</span>
+                    }
+                  </div>
+                </li>
+              }
+            </ul>
+          </div>
+        </div>
+      </div>
+    }
+  `, isInline: true, styles: [".ui-form-error-summary{position:relative;cursor:pointer}.ui-form-error-summary__heading{display:flex;align-items:center;gap:var(--ui-spacing-2, 8px);padding:var(--ui-spacing-2, 8px) 0;outline:none}.ui-form-error-summary__heading:focus{outline:none}.ui-form-error-summary__heading:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-error-summary__icon{color:var(--ui-color-error, #dc2626);flex-shrink:0}.ui-form-error-summary__text{margin:0;color:var(--ui-color-error, #dc2626);font-size:var(--ui-font-size-sm, 14px);font-family:var(--ui-font-family);line-height:1.4}.ui-form-error-summary__text strong{font-weight:var(--ui-font-weight-semibold, 600)}.ui-form-error-summary__dropdown{position:absolute;bottom:100%;left:0;right:0;min-width:320px;max-height:300px;overflow-y:auto;background:var(--ui-color-surface, #fff);border:1px solid var(--ui-color-border, #e5e7eb);border-radius:var(--ui-radius-lg, 8px);box-shadow:0 -10px 25px -3px #0000001a,0 -4px 6px -2px #0000000d;z-index:1000;margin-bottom:var(--ui-spacing-2, 8px);opacity:0;visibility:hidden;transform:translateY(10px);transition:opacity .2s ease-in-out,visibility .2s ease-in-out,transform .2s ease-in-out}.ui-form-error-summary__dropdown--visible{opacity:1;visibility:visible;transform:translateY(0)}.ui-form-error-summary__dropdown-content{padding:var(--ui-spacing-4, 16px)}.ui-form-error-summary__dropdown-title{margin:0 0 var(--ui-spacing-3, 12px) 0;color:var(--ui-color-text, #374151);font-size:var(--ui-font-size-sm, 14px);font-weight:var(--ui-font-weight-semibold, 600);font-family:var(--ui-font-family)}.ui-form-error-summary__list{list-style:none;padding:0;margin:0}.ui-form-error-summary__item{padding:var(--ui-spacing-3, 12px);border-radius:var(--ui-radius-md, 6px);cursor:pointer;transition:background-color .15s ease;border:1px solid transparent;margin-bottom:var(--ui-spacing-2, 8px);outline:none}.ui-form-error-summary__item:focus{outline:none}.ui-form-error-summary__item:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-error-summary__item:last-child{margin-bottom:0}.ui-form-error-summary__item:hover{background:var(--ui-color-surface-hover, #f9fafb);border-color:var(--ui-color-border, #e5e7eb)}.ui-form-error-summary__field-name{display:flex;align-items:center;gap:var(--ui-spacing-2, 8px);font-weight:var(--ui-font-weight-semibold, 600);color:var(--ui-color-text, #374151);font-size:var(--ui-font-size-sm, 14px);font-family:var(--ui-font-family);margin-bottom:4px}.ui-form-error-summary__arrow{color:var(--ui-color-text-muted, #6b7280);flex-shrink:0;transition:transform .15s ease}.ui-form-error-summary__item:hover .ui-form-error-summary__arrow{transform:translate(4px)}.ui-form-error-summary__messages{color:var(--ui-color-error, #dc2626);font-size:var(--ui-font-size-xs, 13px);font-family:var(--ui-font-family);line-height:1.4;margin-left:22px}@media (max-width: 768px){.ui-form-error-summary__dropdown{position:fixed;inset:50% 16px auto;transform:translateY(-50%);margin-bottom:0}.ui-form-error-summary__dropdown--visible{transform:translateY(-50%)}}\n"], dependencies: [{ kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i1.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormErrorSummaryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-form-error-summary', standalone: true, imports: [LucideAngularModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: `
+    @if (errors.length > 0) {
+      <div
+        class="ui-form-error-summary"
+        (mouseenter)="showDropdown = true"
+        (mouseleave)="showDropdown = false"
+      >
+        <!-- Indicatore errori con icona e messaggio -->
+        <div class="ui-form-error-summary__heading"
+          (click)="showDropdown = !showDropdown"
+          role="button"
+          tabindex="0"
+          [attr.aria-label]="displayCount + ' errori nel form'"
+          (keydown.enter)="showDropdown = !showDropdown"
+          (keydown.space)="showDropdown = !showDropdown; $event.preventDefault()"
+        >
+          <lucide-icon name="alert-circle" [size]="20" class="ui-form-error-summary__icon" aria-hidden="true" />
+          <p class="ui-form-error-summary__text">
+            Sono presenti <strong>{{ displayCount }}</strong>
+            {{ displayCount === 1 ? 'errore' : 'errori' }} nel form.
+          </p>
+        </div>
+
+        <!-- Dropdown dettaglio -->
+        <div
+          class="ui-form-error-summary__dropdown"
+          [class.ui-form-error-summary__dropdown--visible]="showDropdown"
+          role="list"
+          aria-label="Elenco errori del form"
+        >
+          <div class="ui-form-error-summary__dropdown-content">
+            <h4 class="ui-form-error-summary__dropdown-title">Dettagli errori:</h4>
+            <ul class="ui-form-error-summary__list">
+              @for (detail of errors; track detail.fieldKey) {
+                <li
+                  class="ui-form-error-summary__item"
+                  role="listitem"
+                  (click)="onFieldClick(detail.fieldKey)"
+                  tabindex="0"
+                  (keydown.enter)="onFieldClick(detail.fieldKey)"
+                >
+                  <div class="ui-form-error-summary__field-name">
+                    <lucide-icon name="arrow-right" [size]="14" class="ui-form-error-summary__arrow" aria-hidden="true" />
+                    {{ detail.fieldLabel }}
+                  </div>
+                  <div class="ui-form-error-summary__messages">
+                    @for (err of detail.errors; track $index; let last = $last) {
+                      <span>{{ err }}@if (!last) {, }</span>
+                    }
+                  </div>
+                </li>
+              }
+            </ul>
+          </div>
+        </div>
+      </div>
+    }
+  `, styles: [".ui-form-error-summary{position:relative;cursor:pointer}.ui-form-error-summary__heading{display:flex;align-items:center;gap:var(--ui-spacing-2, 8px);padding:var(--ui-spacing-2, 8px) 0;outline:none}.ui-form-error-summary__heading:focus{outline:none}.ui-form-error-summary__heading:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-error-summary__icon{color:var(--ui-color-error, #dc2626);flex-shrink:0}.ui-form-error-summary__text{margin:0;color:var(--ui-color-error, #dc2626);font-size:var(--ui-font-size-sm, 14px);font-family:var(--ui-font-family);line-height:1.4}.ui-form-error-summary__text strong{font-weight:var(--ui-font-weight-semibold, 600)}.ui-form-error-summary__dropdown{position:absolute;bottom:100%;left:0;right:0;min-width:320px;max-height:300px;overflow-y:auto;background:var(--ui-color-surface, #fff);border:1px solid var(--ui-color-border, #e5e7eb);border-radius:var(--ui-radius-lg, 8px);box-shadow:0 -10px 25px -3px #0000001a,0 -4px 6px -2px #0000000d;z-index:1000;margin-bottom:var(--ui-spacing-2, 8px);opacity:0;visibility:hidden;transform:translateY(10px);transition:opacity .2s ease-in-out,visibility .2s ease-in-out,transform .2s ease-in-out}.ui-form-error-summary__dropdown--visible{opacity:1;visibility:visible;transform:translateY(0)}.ui-form-error-summary__dropdown-content{padding:var(--ui-spacing-4, 16px)}.ui-form-error-summary__dropdown-title{margin:0 0 var(--ui-spacing-3, 12px) 0;color:var(--ui-color-text, #374151);font-size:var(--ui-font-size-sm, 14px);font-weight:var(--ui-font-weight-semibold, 600);font-family:var(--ui-font-family)}.ui-form-error-summary__list{list-style:none;padding:0;margin:0}.ui-form-error-summary__item{padding:var(--ui-spacing-3, 12px);border-radius:var(--ui-radius-md, 6px);cursor:pointer;transition:background-color .15s ease;border:1px solid transparent;margin-bottom:var(--ui-spacing-2, 8px);outline:none}.ui-form-error-summary__item:focus{outline:none}.ui-form-error-summary__item:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-error-summary__item:last-child{margin-bottom:0}.ui-form-error-summary__item:hover{background:var(--ui-color-surface-hover, #f9fafb);border-color:var(--ui-color-border, #e5e7eb)}.ui-form-error-summary__field-name{display:flex;align-items:center;gap:var(--ui-spacing-2, 8px);font-weight:var(--ui-font-weight-semibold, 600);color:var(--ui-color-text, #374151);font-size:var(--ui-font-size-sm, 14px);font-family:var(--ui-font-family);margin-bottom:4px}.ui-form-error-summary__arrow{color:var(--ui-color-text-muted, #6b7280);flex-shrink:0;transition:transform .15s ease}.ui-form-error-summary__item:hover .ui-form-error-summary__arrow{transform:translate(4px)}.ui-form-error-summary__messages{color:var(--ui-color-error, #dc2626);font-size:var(--ui-font-size-xs, 13px);font-family:var(--ui-font-family);line-height:1.4;margin-left:22px}@media (max-width: 768px){.ui-form-error-summary__dropdown{position:fixed;inset:50% 16px auto;transform:translateY(-50%);margin-bottom:0}.ui-form-error-summary__dropdown--visible{transform:translateY(-50%)}}\n"] }]
+        }], propDecorators: { errors: [{
+                type: Input
+            }], totalErrorCount: [{
+                type: Input
+            }], fieldClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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