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

package/form-builder-editor/lib/components/form-builder/directives/currency-input.directive.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { ControlValueAccessor } 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 declare class UiCurrencyInputDirective implements ControlValueAccessor, OnInit {
+    private el;
+    private renderer;
+    /** Simbolo valuta visualizzato. @default 'EUR' */
+    currencySymbol: string;
+    /** Numero di decimali. @default 2 */
+    decimalPlaces: number;
+    private rawValue;
+    private onChange;
+    private onTouched;
+    private isFocused;
+    constructor(el: ElementRef<HTMLInputElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(value: string): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private parseInput;
+    /** Mostra il valore formattato con separatori italiani e simbolo. */
+    private displayFormatted;
+    /** Formattazione italiana: 1.234,56 */
+    private formatItalian;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiCurrencyInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiCurrencyInputDirective, "[uiCurrencyInput]", never, { "currencySymbol": { "alias": "currencySymbol"; "required": false; }; "decimalPlaces": { "alias": "decimalPlaces"; "required": false; }; }, {}, never, never, true, never>;
+}

package/form-builder-editor/lib/components/form-builder/form-builder.component.d.ts

@@ -0,0 +1,279 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, AfterViewInit, TemplateRef } from '@angular/core';
+import { FormGroup, FormControl, FormArray } from '@angular/forms';
+import { UiAccordionDescriptor } from '../accordion/index';
+import { UiButtonDescriptor } from '../../components/button/index';
+import { UiFormSchema, UiFormSection, UiFormData, UiFormCustomEvent } from './types/schema.types';
+import { UiFormFieldDescriptor, UiFieldOption, UiCustomFieldTemplateContext } from './types/field.types';
+import { UiFormValidationState, UiFormErrorDetail } from './types/validation.types';
+import * as i0 from "@angular/core";
+/**
+ * Form builder data-driven e schema-based.
+ *
+ * Genera un form completo a partire da uno schema dichiarativo (`UiFormSchema`).
+ * Supporta i tipi di campo del form builder, validazione condizionale, cross-field validation,
+ * date con offset, opzioni dipendenti/dinamiche, sezioni collapsibili,
+ * error summary con scroll-to-field e button override.
+ *
+ * @selector ui-form-builder
+ *
+ * @example
+ * ```html
+ * <ui-form-builder
+ *   [schema]="formSchema"
+ *   [initialData]="userData"
+ *   (formSubmit)="onSubmit($event)"
+ *   (valueChange)="onChange($event)"
+ * />
+ * ```
+ */
+export declare class UiFormBuilderComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    private readonly cdr;
+    private readonly elRef;
+    private readonly conditionService;
+    private readonly validationService;
+    private readonly fieldErrorService;
+    /** @internal Optional BlackBox service — auto-tracks form events when available. */
+    private readonly blackbox;
+    /** @internal Router inject for BlackBox route context. */
+    private readonly bbRouter;
+    /** @internal Optional Logger service — logs form actions when available. */
+    private readonly logger;
+    private readonly destroy$;
+    private valueChangeSub?;
+    /** @internal Listener cleanup for BlackBox focus/blur tracking. */
+    private bbFocusHandler;
+    private bbBlurHandler;
+    /** ID schema corrente -- usato per evitare rebuild superflui. */
+    private currentSchemaId;
+    /** Schema del form. */
+    schema: UiFormSchema;
+    /** Dati iniziali per la prevalorizzazione. */
+    initialData: UiFormData;
+    /** Modalita sola lettura globale. */
+    readonly: boolean;
+    /** Stato disabilitato globale. */
+    disabled: boolean;
+    /** Override dei pulsanti di default. */
+    buttonsOverride?: UiButtonDescriptor[];
+    /** Chiave del pulsante in stato di caricamento. */
+    loadingFor: string | null;
+    /**
+     * Mappa chiave logica → template per campi `type: 'custom'`.
+     * La chiave si risolve con `customConfig.templateKey`, poi `customConfig.component`, poi `field.key`.
+     */
+    customFieldTemplates: Record<string, TemplateRef<unknown>>;
+    /**
+     * Template usato quando non esiste una voce in `customFieldTemplates` per la chiave risolta
+     * (es. un unico `ng-template` con `@switch` sul campo).
+     */
+    customFieldTemplateFallback?: TemplateRef<unknown>;
+    valueChange: EventEmitter<UiFormData>;
+    validationChange: EventEmitter<UiFormValidationState>;
+    formSubmit: EventEmitter<UiFormData>;
+    formReset: EventEmitter<void>;
+    customEvent: EventEmitter<UiFormCustomEvent>;
+    formGroup: FormGroup;
+    /** Mappa campo -> opzioni filtrate (per autocomplete e dependent). */
+    filteredOptions: Record<string, UiFieldOption[]>;
+    /** Campi prevalorizzati (mostrano errori subito). */
+    prevalorizedFields: Set<string>;
+    /** Mappa campo -> regole di validazione (per lookup rapido). */
+    private validationRulesMap;
+    /** Mappa dipendenze: campoTarget -> campi dipendenti. */
+    private fieldDependencies;
+    /** @internal Accordion descriptors per le sezioni collapsibili. */
+    sectionAccordionMap: Map<string, UiAccordionDescriptor[]>;
+    /** @internal Accordion descriptors per le istanze repeatable (sectionId -> descriptors). */
+    repeatableAccordionMap: Map<string, UiAccordionDescriptor[]>;
+    /** Flag per evitare emissioni durante l'inizializzazione. */
+    private isInitializing;
+    /** Tutti i campi di tutte le sezioni (incluse repeatable). */
+    get allFields(): UiFormFieldDescriptor[];
+    /** Campi delle sole sezioni non-repeatable (piatti nel root FormGroup). */
+    get allFlatFields(): UiFormFieldDescriptor[];
+    /** Sezioni con configurazione repeatable. */
+    get repeatableSections(): UiFormSection[];
+    get formErrors(): UiFormErrorDetail[];
+    get formButtons(): UiButtonDescriptor[];
+    ngOnInit(): void;
+    /**
+     * Rileva cambiamenti sugli @Input.
+     * Ricostruisce il form quando cambia lo schema (id diverso).
+     * Cruciale per il wizard che cambia schema ad ogni step.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Inizializza il form dallo schema corrente.
+     * Estratto per poter essere richiamato sia da ngOnInit che da ngOnChanges.
+     */
+    private initFormFromSchema;
+    /**
+     * Pulisce lo stato del form prima di un rebuild.
+     */
+    private destroyForm;
+    private buildForm;
+    /** Costruisce un FormGroup per una singola istanza di sezione repeatable. */
+    private buildInstanceFormGroup;
+    /**
+     * Sets up BlackBox form event tracking.
+     * - Focus/blur: DOM event delegation on the host element
+     * - Value changes: per-field subscriptions with debounce
+     * - Validation errors: per-field statusChanges subscriptions
+     * @internal
+     */
+    private setupBlackboxTracking;
+    /**
+     * Resolve the form field key from a focus/blur DOM event.
+     * Walks up from the event target looking for `formControlName` or `data-field-key`.
+     * @internal
+     */
+    private resolveFieldKeyFromEvent;
+    private applyAllValidators;
+    private evaluateAllConditions;
+    /** Valuta condizioni di visibilita/disabilitazione per un singolo campo nel contesto del FormGroup dato. */
+    private evaluateFieldConditions;
+    private buildDependencyMap;
+    /**
+     * Costruisce la mappa dei descriptors accordion per le sezioni collapsibili.
+     * Ogni sezione collapsibile viene mappata a un singolo UiAccordionDescriptor.
+     * @internal
+     */
+    private buildSectionAccordionMap;
+    /**
+     * Numero di istanze repeatable da creare al build/reset:
+     * almeno `repeatable.min` (se `min > 0` o omesso default 1), mai meno delle righe in `initialData[section.id]`.
+     * Con `min: 0` non si aggiungono righe oltre a quelle già presenti nei dati iniziali.
+     */
+    private getRepeatableInitialInstanceCount;
+    /** Ricostruisce i descriptor accordion per le istanze di una sezione repeatable. */
+    private rebuildRepeatableAccordion;
+    private updateDependentOptions;
+    /** Verifica se un campo e visibile (opzionalmente nel contesto di un FormGroup specifico). */
+    isFieldVisible(fieldKey: string, fg?: FormGroup): boolean;
+    /** Verifica se un campo e obbligatorio (include validazione condizionale). */
+    isFieldRequired(fieldKey: string, fg?: FormGroup): boolean;
+    /** Verifica se una sezione e visibile. */
+    isSectionVisible(sectionId: string): boolean;
+    /** Descriptors accordion per una sezione collapsibile. */
+    getSectionAccordionItems(sectionId: string): UiAccordionDescriptor[];
+    /** Descriptors accordion per le istanze di una sezione repeatable. */
+    getRepeatableAccordionItems(sectionId: string): UiAccordionDescriptor[];
+    /** Verifica se mostrare errori per un campo. */
+    shouldShowFieldErrors(fieldKey: string, fg?: FormGroup): boolean;
+    /** Errori di un campo come array di messaggi. */
+    getFieldErrors(fieldKey: string, fg?: FormGroup): string[];
+    /** Valore completo del form (include campi disabilitati). */
+    getFormValue(): UiFormData;
+    /** Il form e valido. */
+    isFormValid(): boolean;
+    /**
+     * True se tutti i controlli sono validi, ignorando le chiavi indicate
+     * (flat e dentro ogni istanza repeatable).
+     */
+    isFormValidExcludingFieldKeys(excludedKeys: ReadonlySet<string>): boolean;
+    /**
+     * Risolve la chiave per `customFieldTemplates` (`templateKey` → `component` → `field.key`).
+     */
+    resolveCustomTemplateKey(field: UiFormFieldDescriptor): string;
+    /**
+     * Template Angular registrato per il campo custom, o fallback globale.
+     */
+    getCustomTemplateRef(field: UiFormFieldDescriptor): TemplateRef<unknown> | null;
+    /**
+     * Contesto passato a `ngTemplateOutlet` per il campo custom (CVA sul `control`).
+     */
+    getCustomFieldOutletContext(field: UiFormFieldDescriptor, fg: FormGroup, nestedErrorKeyPrefix?: string): UiCustomFieldTemplateContext;
+    /**
+     * Template e contesto in un solo oggetto (evita doppie valutazioni nel template).
+     */
+    getCustomFieldOutlet(field: UiFormFieldDescriptor, fg: FormGroup, nestedErrorKeyPrefix?: string): {
+        template: TemplateRef<unknown>;
+        context: UiCustomFieldTemplateContext;
+    } | null;
+    /** Prefisso chiavi errore per campi custom annidati (flat o repeatable). */
+    buildNestedErrorKeyPrefix(fieldKey: string, instanceKeyPrefix?: string): string;
+    /** Merge errori nested da CVA custom nel dettaglio error-summary. */
+    private appendCustomNestedFieldErrors;
+    private isFormGroupValidExcluding;
+    /** Stato di validazione completo. */
+    getValidationState(): UiFormValidationState;
+    /** Errori dettagliati per l'error summary. */
+    getDetailedFormErrors(): UiFormErrorDetail[];
+    /** Conta errori totali. */
+    getFormErrorsCount(): number;
+    /** Controlla se ci sono errori. */
+    hasFormErrors(): boolean;
+    /** Controllo per un campo. */
+    getFieldControl(key: string): FormControl | null;
+    /** Aggiorna il valore di un campo programmaticamente. */
+    updateFieldValue(key: string, value: any): void;
+    /** Forza la validazione di tutti i campi (incluse istanze repeatable). */
+    validateAllFields(): void;
+    /** Restituisce il FormArray di una sezione repeatable. */
+    getRepeatableArray(sectionId: string): FormArray | null;
+    /** Restituisce il FormGroup di una specifica istanza repeatable. */
+    getInstanceFormGroup(sectionId: string, index: number): FormGroup | null;
+    /** Verifica se e possibile aggiungere nuove istanze. */
+    canAddInstance(sectionId: string): boolean;
+    /** Verifica se e possibile rimuovere istanze. */
+    canRemoveInstance(sectionId: string): boolean;
+    /** Aggiunge una nuova istanza vuota a una sezione repeatable. */
+    addRepeatableInstance(sectionId: string): void;
+    /** Rimuove un'istanza da una sezione repeatable. */
+    removeRepeatableInstance(sectionId: string, index: number): void;
+    /** Duplica un'istanza esistente con i suoi valori. */
+    duplicateRepeatableInstance(sectionId: string, index: number): void;
+    /** Titolo di un'istanza repeatable. */
+    getInstanceTitle(section: UiFormSection, index: number): string;
+    /** Scrolla al campo e lo evidenzia. */
+    scrollToField(fieldKey: string): void;
+    /** Submit del form. */
+    onSubmit(): void;
+    /** Reset del form. */
+    onReset(): void;
+    /** Opzioni per un campo (filtrando per autocomplete query). */
+    getFieldOptions(field: UiFormFieldDescriptor): UiFieldOption[];
+    /** Filtra opzioni per autocomplete. */
+    filterOptions(field: UiFormFieldDescriptor, query: string): void;
+    /** Display fn per autocomplete. */
+    displayFn(options: UiFieldOption[]): (value: any) => string;
+    /** Seleziona tutte le opzioni per multiselect. */
+    selectAll(field: UiFormFieldDescriptor): void;
+    /** Aggiunge un chip al freemultiselect (da token: Enter o virgola). */
+    addFreeChip(field: UiFormFieldDescriptor, event: any): void;
+    /** Aggiunge un chip al freemultiselect sull'evento blur dell'input. */
+    addFreeChipOnBlur(field: UiFormFieldDescriptor, event: FocusEvent): void;
+    /** Rimuove un chip dal freemultiselect. */
+    removeFreeChip(field: UiFormFieldDescriptor, chipValue: string): void;
+    /** Verifica se un chip e protetto dalla cancellazione. */
+    isChipProtected(field: UiFormFieldDescriptor, chipValue: string): boolean;
+    /** Rimuove chip da multiselect. */
+    removeMultiselectChip(field: UiFormFieldDescriptor, chipValue: any): void;
+    /** Trova label di un'opzione dal valore. */
+    getOptionLabel(field: UiFormFieldDescriptor, value: any): string;
+    /** Tipo di input nativo per il campo. */
+    getNativeInputType(field: UiFormFieldDescriptor): string;
+    /**
+     * Genera le classi CSS per il wrapper di un campo,
+     * combinando eventuali cssClasses dallo schema con le classi
+     * responsive per il sistema a griglia base-12.
+     *
+     * Mobile-first: tutti i campi sono span-12 di default (100%).
+     * Le classi `ui-col-{breakpoint}-{n}` attivano la larghezza
+     * configurata solo dal breakpoint indicato in su.
+     *
+     * Breakpoint supportati: sm (≥576px), md (≥768px), lg (≥1024px), xl (≥1280px).
+     */
+    getFieldWrapperClasses(field: UiFormFieldDescriptor): string;
+    /** Character count per textarea/text con maxLength. */
+    getCharCount(fieldKey: string, fg?: FormGroup): {
+        current: number;
+        max: number;
+    } | null;
+    private isObservable;
+    getRepeatableAddButtons(section: UiFormSection): UiButtonDescriptor[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormBuilderComponent, "ui-form-builder", never, { "schema": { "alias": "schema"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "buttonsOverride": { "alias": "buttonsOverride"; "required": false; }; "loadingFor": { "alias": "loadingFor"; "required": false; }; "customFieldTemplates": { "alias": "customFieldTemplates"; "required": false; }; "customFieldTemplateFallback": { "alias": "customFieldTemplateFallback"; "required": false; }; }, { "valueChange": "valueChange"; "validationChange": "validationChange"; "formSubmit": "formSubmit"; "formReset": "formReset"; "customEvent": "customEvent"; }, never, never, true, never>;
+}

package/form-builder-editor/lib/components/form-builder/services/form-condition.service.d.ts

@@ -0,0 +1,46 @@
+import { UiFieldCondition } from '../types/condition.types';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la valutazione delle condizioni di visibilita,
+ * required e disable dei campi del form.
+ *
+ * Supporta 12 operatori di confronto, logica AND/OR
+ * e accesso a valori annidati tramite dot notation.
+ *
+ * @providedIn 'root'
+ */
+export declare class UiFormConditionService {
+    /**
+     * Valuta una singola condizione rispetto ai dati del form.
+     *
+     * @param condition - Condizione da valutare.
+     * @param formData - Stato corrente dei dati del form.
+     * @returns `true` se la condizione e soddisfatta.
+     */
+    evaluateCondition(condition: UiFieldCondition, formData: Record<string, any>): boolean;
+    /**
+     * Valuta un array di condizioni con logica AND/OR.
+     *
+     * La prima condizione stabilisce il valore iniziale.
+     * Le condizioni successive usano la proprieta `logic` per
+     * combinare il risultato (`AND` per default).
+     *
+     * @param conditions - Array di condizioni.
+     * @param formData - Stato corrente dei dati del form.
+     * @returns `true` se le condizioni combinate sono soddisfatte.
+     */
+    evaluateConditions(conditions: UiFieldCondition[], formData: Record<string, any>): boolean;
+    /** Accesso a valori annidati tramite dot notation (es. `'address.city'`). */
+    private getNestedValue;
+    /** Confronto stringa case-insensitive. */
+    private stringContains;
+    /** Confronto numerico generico. */
+    private numericCompare;
+    /**
+     * Verifica se un valore e vuoto in modo robusto.
+     * Gestisce null, undefined, false, stringhe vuote, array vuoti e oggetti vuoti.
+     */
+    private isEmpty;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormConditionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiFormConditionService>;
+}

package/form-builder-editor/lib/components/form-builder/services/form-error-state.matcher.d.ts

@@ -0,0 +1,9 @@
+import { FormControl, FormGroupDirective, NgForm } from '@angular/forms';
+import { ErrorStateMatcher } from '@angular/material/core';
+/**
+ * ErrorStateMatcher condiviso tra form-builder e campi atomici.
+ * Mostra errore quando il controllo è invalido e (touched o dirty).
+ */
+export declare class UiFormErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null, _form: FormGroupDirective | NgForm | null): boolean;
+}

package/form-builder-editor/lib/components/form-builder/services/form-field-error.service.d.ts

@@ -0,0 +1,38 @@
+import { AbstractControl } from '@angular/forms';
+import { UiValidationRule } from '../types/validation.types';
+import * as i0 from "@angular/core";
+/** Opzioni per la visibilità degli errori di un campo. */
+export interface UiFieldErrorDisplayOptions {
+    /** Tratta il campo come prevalorizzato (mostra errori anche senza touched). */
+    treatAsPrevalorized?: boolean;
+}
+/**
+ * Servizio condiviso per messaggi di errore, visibilità errori e conteggio caratteri
+ * dei campi form-builder e dei componenti atomici standalone.
+ */
+export declare class UiFormFieldErrorService {
+    /**
+     * Restituisce i messaggi di errore user-facing per un controllo.
+     *
+     * @param control Controllo Angular del campo
+     * @param rules Regole di validazione dichiarative (messaggi custom dallo schema)
+     */
+    getFieldErrors(control: AbstractControl | null, rules?: UiValidationRule[]): string[];
+    /**
+     * Indica se mostrare gli errori per un controllo (invalid + touched/dirty/prevalorizzato).
+     */
+    shouldShowFieldErrors(control: AbstractControl | null, options?: UiFieldErrorDisplayOptions): boolean;
+    /**
+     * Conteggio caratteri corrente/massimo per campi text/textarea con maxLength.
+     */
+    getCharCount(control: AbstractControl | null, maxLength?: number): {
+        current: number;
+        max: number;
+    } | null;
+    /** Estrae maxLength dalle regole schema. */
+    resolveMaxLength(rules?: UiValidationRule[]): number | undefined;
+    private normalizeValidationKey;
+    private getDefaultErrorMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormFieldErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiFormFieldErrorService>;
+}

package/form-builder-editor/lib/components/form-builder/services/form-validation.service.d.ts

@@ -0,0 +1,63 @@
+import { AbstractControl, ValidatorFn } from '@angular/forms';
+import { UiValidationRule } from '../types/validation.types';
+import { UiFormConditionService } from './form-condition.service';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la creazione e gestione dei validatori Angular
+ * basati sulle regole dichiarative dello schema del form.
+ *
+ * Supporta validazioni standard, cross-field, date con offset,
+ * file e validatori condizionali.
+ *
+ * @providedIn 'root'
+ */
+export declare class UiFormValidationService {
+    private conditionService;
+    constructor(conditionService: UiFormConditionService);
+    /** Crea un array di validatori Angular dalle regole di validazione. */
+    createValidators(rules: UiValidationRule[]): ValidatorFn[];
+    /**
+     * Crea validatori con supporto condizionale.
+     * Le regole con `conditions` vengono applicate solo se le condizioni sono soddisfatte.
+     */
+    createConditionalValidators(rules: UiValidationRule[], formData: Record<string, any>): ValidatorFn[];
+    /**
+     * Aggiorna i validatori di un campo in base allo stato corrente del form.
+     * Usato per ricalcolare validazioni condizionali quando i dati cambiano.
+     */
+    updateFieldValidators(control: AbstractControl, rules: UiValidationRule[] | undefined, formData: Record<string, any>): void;
+    /** Verifica se un campo dovrebbe mostrare gli errori. */
+    shouldShowFieldErrors(control: AbstractControl): boolean;
+    /** Restituisce i campi correlati da cross-field validation. */
+    getCrossFieldRelatedFields(fieldKey: string, allRules: Record<string, UiValidationRule[]>): string[];
+    /** Verifica se un campo ha validazioni cross-field che lo referenziano. */
+    hasCrossFieldValidations(fieldKey: string, allRules: Record<string, UiValidationRule[]>): boolean;
+    /** Formatta la dimensione del file in una stringa leggibile. */
+    formatFileSize(bytes: number): string;
+    private createValidator;
+    private createCrossFieldValidator;
+    /** Confronto date con date-fns. */
+    private validateDateComparison;
+    /** Confronto numerico. */
+    private validateNumberComparison;
+    private createDateMinValidator;
+    private createDateMaxValidator;
+    /**
+     * Parsa una data di riferimento da keyword o stringa DD/MM/YYYY
+     * e applica un eventuale offset temporale.
+     */
+    private parseReferenceDate;
+    /**
+     * Applica un offset temporale a una data.
+     *
+     * Formato: `numero + unita`
+     * - `y`/`a` = anni, `m` = mesi, `g`/`d` = giorni, `s`/`w` = settimane
+     */
+    private applyDateOffset;
+    private formatRefDate;
+    private createFileSizeValidator;
+    private createFileTypeValidator;
+    private createFileCountValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiFormValidationService>;
+}

package/form-builder-editor/lib/components/form-builder/services/location.service.d.ts

@@ -0,0 +1,83 @@
+import * as i0 from "@angular/core";
+/** Voce nazione nel JSON ottimizzato. */
+export interface MinifiedNazioneOption {
+    /** Codice nazione (es. `'ITA'`). */
+    x: string;
+    /** Descrizione (es. `'Italia'`). */
+    d: string;
+}
+/** Voce provincia/comune nel JSON ottimizzato. */
+export interface MinifiedSelectOption {
+    /** Codice (provincia o comune). */
+    x: string;
+    /** Descrizione. */
+    d: string;
+    /** CAP singolo o multipli. */
+    c?: string | string[];
+}
+/** Nazione. */
+export interface UiNazione {
+    codStatoPk: string;
+    codiceCatastale: string;
+    descrizione: string;
+}
+/** Provincia. */
+export interface UiProvincia {
+    codiceProvinciaPk: string;
+    nomeProvincia: string;
+    siglaProvincia: string;
+    visibile: boolean;
+}
+/** Comune. */
+export interface UiComune {
+    codiceCatastale: string;
+    codiceComunePk: string;
+    comuneSoppresso: boolean;
+    nomeComune: string;
+    prov: UiProvincia;
+    visibile: boolean;
+}
+/**
+ * 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 declare class UiLocationService {
+    private readonly nazioniMap;
+    private readonly locationMap;
+    private readonly nazioniCache;
+    private readonly provinceCache;
+    private readonly comuniCache;
+    constructor();
+    /** Elenco completo delle nazioni (Italia prima). */
+    getNazioni(): Promise<{
+        data: UiNazione[];
+    }>;
+    /** Elenco completo delle province, ordinate alfabeticamente. */
+    getProvince(): Promise<{
+        content: UiProvincia[];
+    }>;
+    /** Elenco dei comuni per una specifica provincia. */
+    getComuniByProvincia(provinciaId: string): Promise<UiComune[]>;
+    /** Elenco dei CAP per un comune. */
+    getCapList(comuneId: string): Promise<string[]>;
+    /** Dati completi di una location (nazione, provincia o comune). */
+    getLocationFullData(type: 'nazione' | 'provincia' | 'comune', id: string, provinciaId?: string): Promise<UiNazione | UiProvincia | UiComune | null>;
+    private initializeCaches;
+    private sortNazioniItaliaFirst;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLocationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiLocationService>;
+}

package/form-builder-editor/lib/components/form-builder/services/nominatim-geocoding.service.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import type { UiGeocodedLocationType, UiLocationGeocodedFieldConfig } from '../types/geocoded-location.types';
+import * as i0 from "@angular/core";
+/** Risposta elementare dell'API search di Nominatim (format=json). */
+interface NominatimSearchItem {
+    place_id: number;
+    lat: string;
+    lon: string;
+    display_name: string;
+    importance?: number;
+    boundingbox?: [string, string, string, string];
+    address?: Record<string, string>;
+}
+/**
+ * Integrazione con l'API pubblica Nominatim (OpenStreetMap) per la ricerca indirizzi.
+ * Mappa i risultati sul tipo {@link UiGeocodedLocationType}.
+ *
+ * In browser è consigliato usare un proxy same-origin per CORS e User-Agent;
+ * vedi {@link UiLocationGeocodedFieldConfig.nominatimBaseUrl}.
+ *
+ * @providedIn root
+ */
+export declare class UiNominatimGeocodingService {
+    private readonly http;
+    /**
+     * Cerca indirizzi in base alla query testuale.
+     *
+     * @param query - Testo libero inserito dall'utente
+     * @param config - Opzioni di ricerca e base URL
+     */
+    search(query: string, config?: UiLocationGeocodedFieldConfig): Observable<UiGeocodedLocationType[]>;
+    /** Converte un risultato Nominatim in {@link UiGeocodedLocationType}. */
+    mapItem(item: NominatimSearchItem): UiGeocodedLocationType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiNominatimGeocodingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiNominatimGeocodingService>;
+}
+export {};

package/form-builder-editor/lib/components/form-builder/sub-components/error-summary/form-error-summary.component.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from '@angular/core';
+import { UiFormErrorDetail } from '../../types/validation.types';
+import * as i0 from "@angular/core";
+/**
+ * Riepilogo stato validazione del form.
+ *
+ * Con errori: indicatore + dropdown hover/click per il dettaglio e navigazione ai campi.
+ * Senza errori: messaggio di stato positivo fisso (no dropdown), UI prevedibile.
+ *
+ * @selector ui-form-error-summary
+ */
+export declare class UiFormErrorSummaryComponent {
+    /** Lista di errori dettagliati per campo. */
+    errors: UiFormErrorDetail[];
+    /** Conteggio totale degli errori (somma di tutti i messaggi). */
+    totalErrorCount: number;
+    /** Testo mostrato quando non ci sono errori. */
+    validMessage: string;
+    /** Emesso quando l'utente clicca su un errore per navigare al campo. */
+    fieldClick: EventEmitter<string>;
+    /** @internal Stato del dropdown (solo con errori). */
+    showDropdown: boolean;
+    /** True se il form ha almeno un errore da mostrare nel summary. */
+    get hasErrors(): boolean;
+    /** Conteggio da visualizzare: usa totalErrorCount se fornito, altrimenti conta dai dettagli. */
+    get displayCount(): number;
+    /** @internal Gestione click su errore. */
+    onFieldClick(fieldKey: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormErrorSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormErrorSummaryComponent, "ui-form-error-summary", never, { "errors": { "alias": "errors"; "required": false; }; "totalErrorCount": { "alias": "totalErrorCount"; "required": false; }; "validMessage": { "alias": "validMessage"; "required": false; }; }, { "fieldClick": "fieldClick"; }, never, never, true, never>;
+}