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

package/esm2022/form-builder/lib/components/form-builder/form-builder.component.mjs

@@ -0,0 +1,1351 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectorRef, ViewEncapsulation, inject, ElementRef, } from '@angular/core';
+import { FormGroup, FormControl, FormArray, ReactiveFormsModule, } from '@angular/forms';
+import { NgTemplateOutlet } from '@angular/common';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatNativeDateModule, DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE, ErrorStateMatcher, } from '@angular/material/core';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatChipsModule } from '@angular/material/chips';
+import { UiAccordionComponent } from '../accordion/index';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { LucideAngularModule } from 'lucide-angular';
+import { Subject } from 'rxjs';
+import { debounceTime, takeUntil, distinctUntilChanged, filter as rxFilter } from 'rxjs/operators';
+import { UiButtonComponent } from '../../components/button/index';
+import { UiButtonAreaComponent } from '../../components/button/button-area.component';
+import { UiBlackboxService } from '../blackbox/blackbox.service';
+import { UiLoggerService } from '../../core/logging/logger.service';
+import { Router } from '@angular/router';
+import { UI_FORM_NESTED_FIELD_ERRORS_KEY, } from './types/validation.types';
+import { UiFormConditionService } from './services/form-condition.service';
+import { UiFormValidationService } from './services/form-validation.service';
+import { UiFormFieldErrorService } from './services/form-field-error.service';
+import { UiFormErrorSummaryComponent } from './sub-components/error-summary/form-error-summary.component';
+import { UiFileInputComponent } from './sub-components/file-input/file-input.component';
+import { UiSpecificaTerritorialeComponent } from './sub-components/specifica-territoriale/specifica-territoriale.component';
+import { UiTableTerritorialeComponent } from './sub-components/table-territoriale/table-territoriale.component';
+import { UiLocationGeocodedComponent } from './sub-components/location-geocoded/location-geocoded.component';
+import { UiFormTextFieldComponent, UiFormTextareaFieldComponent, UiFormNumberFieldComponent, UiFormSelectFieldComponent, UiFormRadioFieldComponent } from './sub-components/form-fields/index';
+import { UiFormErrorStateMatcher } from './services/form-error-state.matcher';
+import { UiItalianDateAdapter, UI_IT_DATE_FORMATS } from './adapters/it-date-adapter';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/material/select";
+import * as i5 from "@angular/material/core";
+import * as i6 from "@angular/material/checkbox";
+import * as i7 from "@angular/material/slide-toggle";
+import * as i8 from "@angular/material/datepicker";
+import * as i9 from "@angular/material/chips";
+import * as i10 from "@angular/material/tooltip";
+import * as i11 from "lucide-angular";
+/**
+ * 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 class UiFormBuilderComponent {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.elRef = inject(ElementRef);
+        this.conditionService = inject(UiFormConditionService);
+        this.validationService = inject(UiFormValidationService);
+        this.fieldErrorService = inject(UiFormFieldErrorService);
+        /** @internal Optional BlackBox service — auto-tracks form events when available. */
+        this.blackbox = inject(UiBlackboxService, { optional: true });
+        /** @internal Router inject for BlackBox route context. */
+        this.bbRouter = inject(Router, { optional: true });
+        /** @internal Optional Logger service — logs form actions when available. */
+        this.logger = inject(UiLoggerService, { optional: true });
+        this.destroy$ = new Subject();
+        /** @internal Listener cleanup for BlackBox focus/blur tracking. */
+        this.bbFocusHandler = null;
+        this.bbBlurHandler = null;
+        /** ID schema corrente -- usato per evitare rebuild superflui. */
+        this.currentSchemaId = null;
+        /** Dati iniziali per la prevalorizzazione. */
+        this.initialData = {};
+        /** Modalita sola lettura globale. */
+        this.readonly = false;
+        /** Stato disabilitato globale. */
+        this.disabled = false;
+        /** Chiave del pulsante in stato di caricamento. */
+        this.loadingFor = null;
+        /**
+         * Mappa chiave logica → template per campi `type: 'custom'`.
+         * La chiave si risolve con `customConfig.templateKey`, poi `customConfig.component`, poi `field.key`.
+         */
+        this.customFieldTemplates = {};
+        // ─── Output ─────────────────────────────────────────────────────
+        this.valueChange = new EventEmitter();
+        this.validationChange = new EventEmitter();
+        this.formSubmit = new EventEmitter();
+        this.formReset = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        /** Mappa campo -> opzioni filtrate (per autocomplete e dependent). */
+        this.filteredOptions = {};
+        /** Campi prevalorizzati (mostrano errori subito). */
+        this.prevalorizedFields = new Set();
+        /** Mappa campo -> regole di validazione (per lookup rapido). */
+        this.validationRulesMap = {};
+        /** Mappa dipendenze: campoTarget -> campi dipendenti. */
+        this.fieldDependencies = new Map();
+        /** @internal Accordion descriptors per le sezioni collapsibili. */
+        this.sectionAccordionMap = new Map();
+        /** @internal Accordion descriptors per le istanze repeatable (sectionId -> descriptors). */
+        this.repeatableAccordionMap = new Map();
+        /** Flag per evitare emissioni durante l'inizializzazione. */
+        this.isInitializing = true;
+    }
+    // ─── Getter calcolati ───────────────────────────────────────────
+    /** Tutti i campi di tutte le sezioni (incluse repeatable). */
+    get allFields() {
+        return this.schema?.sections?.flatMap((s) => s.fields) || [];
+    }
+    /** Campi delle sole sezioni non-repeatable (piatti nel root FormGroup). */
+    get allFlatFields() {
+        return this.schema?.sections?.filter((s) => !s.repeatable).flatMap((s) => s.fields) || [];
+    }
+    /** Sezioni con configurazione repeatable. */
+    get repeatableSections() {
+        return this.schema?.sections?.filter((s) => !!s.repeatable) || [];
+    }
+    get formErrors() {
+        return this.getDetailedFormErrors();
+    }
+    get formButtons() {
+        if (this.buttonsOverride)
+            return this.buttonsOverride;
+        if (!this.schema?.config?.showButtons && this.schema?.config?.showButtons !== undefined)
+            return [];
+        return [
+            { label: this.schema?.config?.buttonLabels?.reset || 'Reset', variant: 'outline', action: () => this.onReset() },
+            {
+                label: this.schema?.config?.buttonLabels?.submit || 'Invia',
+                variant: 'primary',
+                action: () => this.onSubmit(),
+            },
+        ];
+    }
+    // ─── Lifecycle ──────────────────────────────────────────────────
+    //
+    // ORDINE LIFECYCLE ANGULAR:
+    // 1. constructor
+    // 2. ngOnChanges (prima chiamata con valori iniziali)
+    // 3. ngOnInit
+    // 4. ngAfterViewInit
+    // 5. ngOnChanges (chiamate successive per cambio input)
+    //
+    // PER IL WIZARD:
+    // Il wizard crea un nuovo schema (con id diverso) ad ogni cambio step.
+    // Lo schema viene cachato nel wizard per evitare rebuild infiniti.
+    // ngOnChanges rileva il cambio di schema.id e ricostruisce il form.
+    ngOnInit() {
+        this.logger?.logFormAction('init', { schemaId: this.schema?.id ?? 'unknown', hasFormGroup: !!this.formGroup });
+        if (!this.schema) {
+            this.logger?.logFormAction('init', { schemaId: 'unknown', error: 'schema non presente' });
+            return;
+        }
+        this.initFormFromSchema();
+    }
+    /**
+     * 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) {
+        if (changes['schema'] && !changes['schema'].firstChange) {
+            const newSchema = changes['schema'].currentValue;
+            if (newSchema && newSchema.id !== this.currentSchemaId) {
+                this.logger?.debug('form', 'schemaRebuild', {
+                    schemaId: newSchema?.id,
+                    previousSchemaId: this.currentSchemaId,
+                });
+                this.destroyForm();
+                this.initFormFromSchema();
+            }
+        }
+        // Aggiorna lo stato disabled/readonly globalmente
+        if (changes['disabled'] && !changes['disabled'].firstChange && this.formGroup) {
+            this.allFlatFields.forEach((field) => {
+                const control = this.formGroup.get(field.key);
+                if (!control)
+                    return;
+                if (this.disabled && control.enabled) {
+                    control.disable({ emitEvent: false });
+                }
+                else if (!this.disabled && control.disabled && !field.disabled) {
+                    control.enable({ emitEvent: false });
+                }
+            });
+            // Aggiorna disabled anche nelle istanze repeatable
+            for (const section of this.repeatableSections) {
+                const arr = this.getRepeatableArray(section.id);
+                if (!arr)
+                    continue;
+                for (let i = 0; i < arr.length; i++) {
+                    const instanceFg = arr.at(i);
+                    for (const field of section.fields) {
+                        const control = instanceFg.get(field.key);
+                        if (!control)
+                            continue;
+                        if (this.disabled && control.enabled) {
+                            control.disable({ emitEvent: false });
+                        }
+                        else if (!this.disabled && control.disabled && !field.disabled) {
+                            control.enable({ emitEvent: false });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    ngAfterViewInit() {
+        this.logger?.debug('form', 'afterViewInit', {
+            schemaId: this.schema?.id,
+            hasFormGroup: !!this.formGroup,
+            fieldCount: this.formGroup ? Object.keys(this.formGroup.controls).length : 0,
+        });
+    }
+    ngOnDestroy() {
+        this.logger?.logFormAction('destroy', { schemaId: this.currentSchemaId ?? 'unknown' });
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.valueChangeSub?.unsubscribe();
+        // BlackBox: cleanup DOM listeners
+        if (this.bbFocusHandler) {
+            this.elRef.nativeElement.removeEventListener('focusin', this.bbFocusHandler, true);
+        }
+        if (this.bbBlurHandler) {
+            this.elRef.nativeElement.removeEventListener('focusout', this.bbBlurHandler, true);
+        }
+    }
+    /**
+     * Inizializza il form dallo schema corrente.
+     * Estratto per poter essere richiamato sia da ngOnInit che da ngOnChanges.
+     */
+    initFormFromSchema() {
+        if (!this.schema) {
+            this.logger?.logFormAction('init', { schemaId: 'unknown', error: 'schema nullo' });
+            return;
+        }
+        const totalFields = this.schema.sections?.reduce((sum, s) => sum + s.fields.length, 0) ?? 0;
+        this.logger?.logFormAction('init', {
+            schemaId: this.schema.id,
+            sectionCount: this.schema.sections?.length,
+            fieldCount: totalFields,
+        });
+        this.currentSchemaId = this.schema.id;
+        this.buildSectionAccordionMap();
+        this.buildForm();
+        // Dopo il FormArray reale, allinea i descriptor accordion (max tra min e righe initialData).
+        for (const section of this.repeatableSections) {
+            this.rebuildRepeatableAccordion(section);
+        }
+        this.isInitializing = false;
+        this.logger?.debug('form', 'formBuilt', {
+            schemaId: this.schema.id,
+            controlKeys: Object.keys(this.formGroup.controls),
+        });
+    }
+    /**
+     * Pulisce lo stato del form prima di un rebuild.
+     */
+    destroyForm() {
+        this.logger?.debug('form', 'destroyForm', { schemaId: this.currentSchemaId });
+        this.valueChangeSub?.unsubscribe();
+        this.valueChangeSub = undefined;
+        this.filteredOptions = {};
+        this.prevalorizedFields.clear();
+        this.validationRulesMap = {};
+        this.fieldDependencies.clear();
+        this.sectionAccordionMap.clear();
+        this.isInitializing = true;
+        this.currentSchemaId = null;
+    }
+    // ─── Costruzione form ───────────────────────────────────────────
+    buildForm() {
+        const controls = {};
+        // Campi piatti (sezioni non-repeatable)
+        for (const field of this.allFlatFields) {
+            const initialValue = this.initialData?.[field.key] ?? field.defaultValue ?? null;
+            const isDisabled = field.disabled || this.disabled;
+            const control = new FormControl({ value: initialValue, disabled: isDisabled });
+            if (field.validation?.length) {
+                this.validationRulesMap[field.key] = field.validation;
+            }
+            if (initialValue != null && initialValue !== '' && initialValue !== false) {
+                this.prevalorizedFields.add(field.key);
+            }
+            if (field.options && !this.isObservable(field.options)) {
+                this.filteredOptions[field.key] = [...field.options];
+            }
+            controls[field.key] = control;
+        }
+        // FormArray per sezioni repeatable
+        for (const section of this.repeatableSections) {
+            const initialArray = this.initialData?.[section.id];
+            const count = this.getRepeatableInitialInstanceCount(section);
+            const groups = [];
+            for (let i = 0; i < count; i++) {
+                groups.push(this.buildInstanceFormGroup(section, initialArray?.[i]));
+            }
+            controls[section.id] = new FormArray(groups);
+        }
+        this.formGroup = new FormGroup(controls);
+        // Applica validatori iniziali
+        this.applyAllValidators();
+        // Registra dipendenze
+        this.buildDependencyMap();
+        // Sottoscrivi ai cambiamenti di valore
+        this.valueChangeSub = this.formGroup.valueChanges.pipe(debounceTime(50), takeUntil(this.destroy$)).subscribe(() => {
+            this.evaluateAllConditions();
+            this.updateDependentOptions();
+            if (!this.isInitializing) {
+                this.valueChange.emit(this.getFormValue());
+                this.validationChange.emit(this.getValidationState());
+                this.cdr.markForCheck();
+            }
+        });
+        // Valutazione condizioni iniziale
+        this.evaluateAllConditions();
+        // BlackBox: setup form event tracking
+        this.setupBlackboxTracking();
+    }
+    /** Costruisce un FormGroup per una singola istanza di sezione repeatable. */
+    buildInstanceFormGroup(section, data) {
+        const controls = {};
+        for (const field of section.fields) {
+            const initialValue = data?.[field.key] ?? field.defaultValue ?? null;
+            const isDisabled = field.disabled || this.disabled;
+            controls[field.key] = new FormControl({ value: initialValue, disabled: isDisabled });
+            if (field.options && !this.isObservable(field.options)) {
+                this.filteredOptions[field.key] = [...field.options];
+            }
+        }
+        const fg = new FormGroup(controls);
+        // Applica validatori all'istanza
+        for (const field of section.fields) {
+            if (field.validation?.length) {
+                const formData = fg.getRawValue();
+                this.validationService.updateFieldValidators(fg.get(field.key), field.validation, formData);
+            }
+        }
+        return fg;
+    }
+    // ─── BlackBox form tracking ──────────────────────────────────────
+    /**
+     * 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
+     */
+    setupBlackboxTracking() {
+        if (!this.blackbox)
+            return;
+        const config = this.blackbox.getConfig().formTracking;
+        const currentRoute = this.bbRouter?.url ?? '';
+        const formId = this.schema?.id ?? 'unknown';
+        // Focus tracking via event delegation
+        if (config.trackFocus) {
+            this.bbFocusHandler = (e) => {
+                const fieldKey = this.resolveFieldKeyFromEvent(e);
+                if (!fieldKey)
+                    return;
+                this.blackbox.trackFormEvent({
+                    timestamp: Date.now(),
+                    route: this.bbRouter?.url ?? currentRoute,
+                    formId,
+                    fieldKey,
+                    eventType: 'focus',
+                });
+            };
+            this.elRef.nativeElement.addEventListener('focusin', this.bbFocusHandler, true);
+        }
+        // Blur tracking via event delegation
+        if (config.trackBlur) {
+            this.bbBlurHandler = (e) => {
+                const fieldKey = this.resolveFieldKeyFromEvent(e);
+                if (!fieldKey)
+                    return;
+                this.blackbox.trackFormEvent({
+                    timestamp: Date.now(),
+                    route: this.bbRouter?.url ?? currentRoute,
+                    formId,
+                    fieldKey,
+                    eventType: 'blur',
+                });
+            };
+            this.elRef.nativeElement.addEventListener('focusout', this.bbBlurHandler, true);
+        }
+        // Per-field value change + validation tracking
+        for (const field of this.allFields) {
+            const control = this.formGroup.get(field.key);
+            if (!control)
+                continue;
+            // Value changes
+            if (config.trackValueChanges) {
+                control.valueChanges
+                    .pipe(debounceTime(config.debounceMs), distinctUntilChanged(), takeUntil(this.destroy$))
+                    .subscribe((value) => {
+                    this.blackbox.trackFormEvent({
+                        timestamp: Date.now(),
+                        route: this.bbRouter?.url ?? currentRoute,
+                        formId,
+                        fieldKey: field.key,
+                        eventType: 'valueChange',
+                        metadata: {
+                            value: config.trackValues ? value : undefined,
+                            valid: control.valid,
+                            formValues: config.trackValues ? this.formGroup.getRawValue() : undefined,
+                        },
+                    });
+                });
+            }
+            // Validation errors
+            if (config.trackValidation) {
+                control.statusChanges
+                    .pipe(rxFilter((status) => status === 'INVALID'), distinctUntilChanged(), takeUntil(this.destroy$))
+                    .subscribe(() => {
+                    const errors = control.errors
+                        ? Object.keys(control.errors)
+                        : [];
+                    this.blackbox.trackFormEvent({
+                        timestamp: Date.now(),
+                        route: this.bbRouter?.url ?? currentRoute,
+                        formId,
+                        fieldKey: field.key,
+                        eventType: 'validationError',
+                        metadata: {
+                            valid: false,
+                            errors,
+                        },
+                    });
+                });
+            }
+        }
+    }
+    /**
+     * 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
+     */
+    resolveFieldKeyFromEvent(e) {
+        let target = e.target;
+        const maxDepth = 5;
+        let depth = 0;
+        while (target && depth < maxDepth) {
+            // formControlName attribute
+            const fcn = target.getAttribute('formControlName');
+            if (fcn)
+                return fcn;
+            // data-field-key attribute
+            const dfk = target.getAttribute('data-field-key');
+            if (dfk)
+                return dfk;
+            target = target.parentElement;
+            depth++;
+        }
+        return null;
+    }
+    // ─── Validazione ────────────────────────────────────────────────
+    applyAllValidators() {
+        // Campi piatti
+        for (const field of this.allFlatFields) {
+            if (field.validation?.length) {
+                const formData = this.formGroup.getRawValue();
+                this.validationService.updateFieldValidators(this.formGroup.get(field.key), field.validation, formData);
+            }
+        }
+        // Campi nelle istanze repeatable
+        for (const section of this.repeatableSections) {
+            const arr = this.getRepeatableArray(section.id);
+            if (!arr)
+                continue;
+            for (let i = 0; i < arr.length; i++) {
+                const instanceFg = arr.at(i);
+                for (const field of section.fields) {
+                    if (field.validation?.length) {
+                        const formData = instanceFg.getRawValue();
+                        this.validationService.updateFieldValidators(instanceFg.get(field.key), field.validation, formData);
+                    }
+                }
+            }
+        }
+    }
+    // ─── Condizioni ─────────────────────────────────────────────────
+    evaluateAllConditions() {
+        const formData = this.formGroup.getRawValue();
+        // Campi piatti
+        for (const field of this.allFlatFields) {
+            this.evaluateFieldConditions(field, this.formGroup, formData);
+        }
+        // Campi nelle istanze repeatable (scope intra-istanza)
+        for (const section of this.repeatableSections) {
+            const arr = this.getRepeatableArray(section.id);
+            if (!arr)
+                continue;
+            for (let i = 0; i < arr.length; i++) {
+                const instanceFg = arr.at(i);
+                const instanceData = instanceFg.getRawValue();
+                for (const field of section.fields) {
+                    this.evaluateFieldConditions(field, instanceFg, instanceData);
+                }
+            }
+        }
+    }
+    /** Valuta condizioni di visibilita/disabilitazione per un singolo campo nel contesto del FormGroup dato. */
+    evaluateFieldConditions(field, fg, formData) {
+        if (field.conditions?.length) {
+            const visible = this.conditionService.evaluateConditions(field.conditions, formData);
+            const control = fg.get(field.key);
+            if (control) {
+                if (!visible && control.enabled) {
+                    control.disable({ emitEvent: false });
+                    if (!field.freezeValueOnDisable) {
+                        control.setValue(field.defaultValue ?? null, { emitEvent: false });
+                    }
+                }
+                else if (visible && control.disabled && !field.disabled && !this.disabled) {
+                    control.enable({ emitEvent: false });
+                }
+            }
+        }
+        if (field.disableConditions?.length && !field.conditions?.length) {
+            const shouldDisable = this.conditionService.evaluateConditions(field.disableConditions, formData);
+            const control = fg.get(field.key);
+            if (control) {
+                if (shouldDisable && control.enabled) {
+                    control.disable({ emitEvent: false });
+                    if (!field.freezeValueOnDisable) {
+                        control.setValue(field.defaultValue ?? null, { emitEvent: false });
+                    }
+                }
+                else if (!shouldDisable && control.disabled && !field.disabled && !this.disabled) {
+                    control.enable({ emitEvent: false });
+                }
+            }
+        }
+        if (field.validation?.some((r) => r.conditions?.length)) {
+            this.validationService.updateFieldValidators(fg.get(field.key), field.validation, formData);
+        }
+    }
+    // ─── Dipendenze opzioni ─────────────────────────────────────────
+    buildDependencyMap() {
+        for (const field of this.allFields) {
+            if (field.dependentOptions?.dependsOn) {
+                const depKey = field.dependentOptions.dependsOn;
+                if (!this.fieldDependencies.has(depKey)) {
+                    this.fieldDependencies.set(depKey, new Set());
+                }
+                this.fieldDependencies.get(depKey).add(field.key);
+            }
+        }
+    }
+    /**
+     * Costruisce la mappa dei descriptors accordion per le sezioni collapsibili.
+     * Ogni sezione collapsibile viene mappata a un singolo UiAccordionDescriptor.
+     * @internal
+     */
+    buildSectionAccordionMap() {
+        this.sectionAccordionMap.clear();
+        this.repeatableAccordionMap.clear();
+        for (const section of this.schema.sections) {
+            if (section.repeatable) {
+                this.rebuildRepeatableAccordion(section);
+            }
+            else if (section.collapsible) {
+                this.sectionAccordionMap.set(section.id, [{
+                        id: section.id,
+                        title: section.title || '',
+                        icon: section.icon,
+                        expanded: !section.collapsed,
+                        subtitle: section.description,
+                    }]);
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    getRepeatableInitialInstanceCount(section) {
+        const cfg = section.repeatable;
+        if (!cfg)
+            return 0;
+        const initialArray = this.initialData?.[section.id];
+        const initialLen = initialArray?.length ?? 0;
+        const minReq = cfg.min;
+        if (minReq === 0) {
+            return initialLen;
+        }
+        const minInstances = minReq ?? 1;
+        return Math.max(initialLen, minInstances);
+    }
+    /** Ricostruisce i descriptor accordion per le istanze di una sezione repeatable. */
+    rebuildRepeatableAccordion(section) {
+        const arr = this.getRepeatableArray(section.id);
+        const count = arr?.length ?? this.getRepeatableInitialInstanceCount(section);
+        const titleTemplate = section.repeatable.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');
+        const items = [];
+        for (let i = 0; i < count; i++) {
+            items.push({
+                id: `${section.id}-${i}`,
+                title: titleTemplate.replace('{index}', String(i + 1)),
+                icon: section.icon,
+                expanded: true,
+                index: i,
+            });
+        }
+        this.repeatableAccordionMap.set(section.id, items);
+    }
+    updateDependentOptions() {
+        const formData = this.formGroup.getRawValue();
+        for (const field of this.allFields) {
+            // Dynamic options
+            if (field.dynamicOptions) {
+                if (field.dynamicOptions.type === 'year-range') {
+                    const min = field.dynamicOptions.minYear || new Date().getFullYear() - 10;
+                    const max = field.dynamicOptions.maxYear || new Date().getFullYear();
+                    const opts = [];
+                    for (let y = max; y >= min; y--) {
+                        opts.push({ value: y, label: String(y) });
+                    }
+                    this.filteredOptions[field.key] = opts;
+                }
+                else if (field.dynamicOptions.generator) {
+                    this.filteredOptions[field.key] = field.dynamicOptions.generator(formData);
+                }
+            }
+            // Dependent options
+            if (field.dependentOptions && field.options && !this.isObservable(field.options)) {
+                const dep = field.dependentOptions;
+                const depValue = formData[dep.dependsOn];
+                const allOptions = field.options;
+                if (depValue == null || depValue === '') {
+                    this.filteredOptions[field.key] = [...allOptions];
+                    continue;
+                }
+                this.filteredOptions[field.key] = allOptions.filter((opt) => {
+                    if (dep.filterType === 'custom' && dep.filterFn) {
+                        return dep.filterFn(opt, depValue, formData);
+                    }
+                    const optVal = Number(opt.value);
+                    const depVal = Number(depValue);
+                    if (isNaN(optVal) || isNaN(depVal))
+                        return true;
+                    switch (dep.filterType) {
+                        case 'greater_than':
+                            return optVal > depVal;
+                        case 'greater_equal':
+                            return optVal >= depVal;
+                        case 'less_than':
+                            return optVal < depVal;
+                        case 'less_equal':
+                            return optVal <= depVal;
+                        case 'equals':
+                            return optVal === depVal;
+                        case 'not_equals':
+                            return optVal !== depVal;
+                        default:
+                            return true;
+                    }
+                });
+            }
+        }
+    }
+    // ─── API pubblica ───────────────────────────────────────────────
+    /** Verifica se un campo e visibile (opzionalmente nel contesto di un FormGroup specifico). */
+    isFieldVisible(fieldKey, fg) {
+        const field = this.allFields.find((f) => f.key === fieldKey);
+        if (!field?.conditions?.length)
+            return true;
+        const target = fg || this.formGroup;
+        return this.conditionService.evaluateConditions(field.conditions, target.getRawValue());
+    }
+    /** Verifica se un campo e obbligatorio (include validazione condizionale). */
+    isFieldRequired(fieldKey, fg) {
+        const field = this.allFields.find((f) => f.key === fieldKey);
+        if (field?.required)
+            return true;
+        const rules = field?.validation || [];
+        const target = fg || this.formGroup;
+        const formData = target.getRawValue();
+        return rules.some((r) => {
+            if (r.type !== 'required')
+                return false;
+            if (!r.conditions?.length)
+                return true;
+            return this.conditionService.evaluateConditions(r.conditions, formData);
+        });
+    }
+    /** Verifica se una sezione e visibile. */
+    isSectionVisible(sectionId) {
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section?.conditions?.length)
+            return true;
+        return this.conditionService.evaluateConditions(section.conditions, this.formGroup.getRawValue());
+    }
+    /** Descriptors accordion per una sezione collapsibile. */
+    getSectionAccordionItems(sectionId) {
+        return this.sectionAccordionMap.get(sectionId) || [];
+    }
+    /** Descriptors accordion per le istanze di una sezione repeatable. */
+    getRepeatableAccordionItems(sectionId) {
+        return this.repeatableAccordionMap.get(sectionId) || [];
+    }
+    /** Verifica se mostrare errori per un campo. */
+    shouldShowFieldErrors(fieldKey, fg) {
+        const target = fg || this.formGroup;
+        const control = target.get(fieldKey);
+        return this.fieldErrorService.shouldShowFieldErrors(control, {
+            treatAsPrevalorized: this.prevalorizedFields.has(fieldKey),
+        });
+    }
+    /** Errori di un campo come array di messaggi. */
+    getFieldErrors(fieldKey, fg) {
+        const target = fg || this.formGroup;
+        const control = target.get(fieldKey);
+        const field = this.allFields.find((f) => f.key === fieldKey);
+        return this.fieldErrorService.getFieldErrors(control, field?.validation);
+    }
+    /** Valore completo del form (include campi disabilitati). */
+    getFormValue() {
+        return this.formGroup.getRawValue();
+    }
+    /** Il form e valido. */
+    isFormValid() {
+        return this.formGroup.valid;
+    }
+    /**
+     * True se tutti i controlli sono validi, ignorando le chiavi indicate
+     * (flat e dentro ogni istanza repeatable).
+     */
+    isFormValidExcludingFieldKeys(excludedKeys) {
+        return this.isFormGroupValidExcluding(this.formGroup, excludedKeys);
+    }
+    /**
+     * Risolve la chiave per `customFieldTemplates` (`templateKey` → `component` → `field.key`).
+     */
+    resolveCustomTemplateKey(field) {
+        const cc = field.customConfig;
+        return cc?.templateKey ?? cc?.component ?? field.key;
+    }
+    /**
+     * Template Angular registrato per il campo custom, o fallback globale.
+     */
+    getCustomTemplateRef(field) {
+        const key = this.resolveCustomTemplateKey(field);
+        return this.customFieldTemplates[key] ?? this.customFieldTemplateFallback ?? null;
+    }
+    /**
+     * Contesto passato a `ngTemplateOutlet` per il campo custom (CVA sul `control`).
+     */
+    getCustomFieldOutletContext(field, fg, nestedErrorKeyPrefix) {
+        const control = fg.get(field.key);
+        return {
+            $implicit: field,
+            field,
+            formGroup: fg,
+            control,
+            config: field.customConfig?.config ?? {},
+            nestedErrorKeyPrefix,
+            emitCustomEvent: (event, data) => {
+                this.customEvent.emit({ field: field.key, event, data });
+            },
+        };
+    }
+    /**
+     * Template e contesto in un solo oggetto (evita doppie valutazioni nel template).
+     */
+    getCustomFieldOutlet(field, fg, nestedErrorKeyPrefix) {
+        const template = this.getCustomTemplateRef(field);
+        if (!template)
+            return null;
+        return { template, context: this.getCustomFieldOutletContext(field, fg, nestedErrorKeyPrefix) };
+    }
+    /** Prefisso chiavi errore per campi custom annidati (flat o repeatable). */
+    buildNestedErrorKeyPrefix(fieldKey, instanceKeyPrefix) {
+        const base = instanceKeyPrefix ? `${instanceKeyPrefix}${fieldKey}` : fieldKey;
+        return `${base}__`;
+    }
+    /** Merge errori nested da CVA custom nel dettaglio error-summary. */
+    appendCustomNestedFieldErrors(details, field, control, labelPrefix, nestedErrorKeyPrefix) {
+        if (field.type !== 'custom')
+            return;
+        const nested = control.errors?.[UI_FORM_NESTED_FIELD_ERRORS_KEY];
+        if (!Array.isArray(nested) || nested.length === 0)
+            return;
+        for (const item of nested) {
+            if (!item?.errors?.length)
+                continue;
+            const relativeKey = item.fieldKey ?? '';
+            details.push({
+                fieldKey: relativeKey ? `${nestedErrorKeyPrefix}${relativeKey}` : nestedErrorKeyPrefix.slice(0, -2),
+                fieldLabel: `${labelPrefix} > ${item.fieldLabel}`,
+                errors: item.errors,
+            });
+        }
+    }
+    isFormGroupValidExcluding(group, excludedKeys) {
+        for (const key of Object.keys(group.controls)) {
+            const c = group.get(key);
+            if (!c)
+                continue;
+            if (c instanceof FormArray) {
+                for (let i = 0; i < c.length; i++) {
+                    const row = c.at(i);
+                    if (row instanceof FormGroup && !this.isFormGroupValidExcluding(row, excludedKeys)) {
+                        return false;
+                    }
+                }
+            }
+            else if (c instanceof FormGroup) {
+                if (!this.isFormGroupValidExcluding(c, excludedKeys))
+                    return false;
+            }
+            else if (c instanceof FormControl) {
+                if (excludedKeys.has(key))
+                    continue;
+                if (c.invalid)
+                    return false;
+            }
+        }
+        return true;
+    }
+    /** Stato di validazione completo. */
+    getValidationState() {
+        const errors = {};
+        const dirty = [];
+        const touched = [];
+        for (const field of this.allFlatFields) {
+            const control = this.formGroup.get(field.key);
+            if (!control)
+                continue;
+            if (control.dirty)
+                dirty.push(field.key);
+            if (control.touched)
+                touched.push(field.key);
+            const fieldErrors = this.getFieldErrors(field.key);
+            if (fieldErrors.length)
+                errors[field.key] = fieldErrors;
+        }
+        // Includi errori delle istanze repeatable
+        for (const section of this.repeatableSections) {
+            const arr = this.getRepeatableArray(section.id);
+            if (!arr)
+                continue;
+            for (let i = 0; i < arr.length; i++) {
+                const instanceFg = arr.at(i);
+                for (const field of section.fields) {
+                    const control = instanceFg.get(field.key);
+                    if (!control)
+                        continue;
+                    const prefixedKey = `${section.id}[${i}].${field.key}`;
+                    if (control.dirty)
+                        dirty.push(prefixedKey);
+                    if (control.touched)
+                        touched.push(prefixedKey);
+                    const fieldErrors = this.getFieldErrors(field.key, instanceFg);
+                    if (fieldErrors.length)
+                        errors[prefixedKey] = fieldErrors;
+                }
+            }
+        }
+        return { valid: this.formGroup.valid, errors, dirty, touched };
+    }
+    /** Errori dettagliati per l'error summary. */
+    getDetailedFormErrors() {
+        const details = [];
+        // Campi piatti
+        for (const field of this.allFlatFields) {
+            if (field.type === 'flag' || field.type === 'divider')
+                continue;
+            if (!this.isFieldVisible(field.key))
+                continue;
+            const control = this.formGroup.get(field.key);
+            if (!control?.errors)
+                continue;
+            const nestedPrefix = this.buildNestedErrorKeyPrefix(field.key);
+            this.appendCustomNestedFieldErrors(details, field, control, field.label, nestedPrefix);
+            if (field.type === 'custom' && control.errors[UI_FORM_NESTED_FIELD_ERRORS_KEY]) {
+                continue;
+            }
+            const errors = this.getFieldErrors(field.key);
+            if (errors.length) {
+                details.push({ fieldKey: field.key, fieldLabel: field.label, errors });
+            }
+        }
+        // Campi nelle istanze repeatable
+        for (const section of this.repeatableSections) {
+            const arr = this.getRepeatableArray(section.id);
+            if (!arr)
+                continue;
+            const titleTemplate = section.repeatable.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');
+            for (let i = 0; i < arr.length; i++) {
+                const instanceFg = arr.at(i);
+                const instanceLabel = titleTemplate.replace('{index}', String(i + 1));
+                const instanceKeyPrefix = `${section.id}[${i}].`;
+                for (const field of section.fields) {
+                    if (field.type === 'flag' || field.type === 'divider')
+                        continue;
+                    if (!this.isFieldVisible(field.key, instanceFg))
+                        continue;
+                    const control = instanceFg.get(field.key);
+                    if (!control?.errors)
+                        continue;
+                    const nestedPrefix = this.buildNestedErrorKeyPrefix(field.key, instanceKeyPrefix);
+                    this.appendCustomNestedFieldErrors(details, field, control, `${instanceLabel} > ${field.label}`, nestedPrefix);
+                    if (field.type === 'custom' && control.errors[UI_FORM_NESTED_FIELD_ERRORS_KEY]) {
+                        continue;
+                    }
+                    const errors = this.getFieldErrors(field.key, instanceFg);
+                    if (errors.length) {
+                        details.push({
+                            fieldKey: `${section.id}[${i}].${field.key}`,
+                            fieldLabel: `${instanceLabel} > ${field.label}`,
+                            errors,
+                        });
+                    }
+                }
+            }
+        }
+        return details;
+    }
+    /** Conta errori totali. */
+    getFormErrorsCount() {
+        return this.getDetailedFormErrors().reduce((sum, d) => sum + d.errors.length, 0);
+    }
+    /** Controlla se ci sono errori. */
+    hasFormErrors() {
+        return this.getFormErrorsCount() > 0;
+    }
+    /** Controllo per un campo. */
+    getFieldControl(key) {
+        return this.formGroup.get(key) ?? null;
+    }
+    /** Aggiorna il valore di un campo programmaticamente. */
+    updateFieldValue(key, value) {
+        const control = this.formGroup.get(key);
+        if (control) {
+            control.setValue(value);
+            control.markAsDirty();
+        }
+    }
+    /** Forza la validazione di tutti i campi (incluse istanze repeatable). */
+    validateAllFields() {
+        // Campi piatti
+        Object.keys(this.formGroup.controls).forEach((key) => {
+            const control = this.formGroup.get(key);
+            if (control instanceof FormArray) {
+                for (let i = 0; i < control.length; i++) {
+                    const fg = control.at(i);
+                    Object.keys(fg.controls).forEach((fk) => {
+                        const c = fg.get(fk);
+                        c?.markAsTouched();
+                        c?.markAsDirty();
+                        c?.updateValueAndValidity();
+                    });
+                }
+            }
+            else {
+                control?.markAsTouched();
+                control?.markAsDirty();
+                control?.updateValueAndValidity();
+            }
+        });
+        this.cdr.markForCheck();
+    }
+    // ─── API Repeatable ────────────────────────────────────────────
+    /** Restituisce il FormArray di una sezione repeatable. */
+    getRepeatableArray(sectionId) {
+        const control = this.formGroup?.get(sectionId);
+        return control instanceof FormArray ? control : null;
+    }
+    /** Restituisce il FormGroup di una specifica istanza repeatable. */
+    getInstanceFormGroup(sectionId, index) {
+        const arr = this.getRepeatableArray(sectionId);
+        return arr?.at(index) ?? null;
+    }
+    /** Verifica se e possibile aggiungere nuove istanze. */
+    canAddInstance(sectionId) {
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section?.repeatable)
+            return false;
+        const arr = this.getRepeatableArray(sectionId);
+        if (!arr)
+            return false;
+        return section.repeatable.max == null || arr.length < section.repeatable.max;
+    }
+    /** Verifica se e possibile rimuovere istanze. */
+    canRemoveInstance(sectionId) {
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section?.repeatable)
+            return false;
+        const arr = this.getRepeatableArray(sectionId);
+        if (!arr)
+            return false;
+        return arr.length > (section.repeatable.min ?? 1);
+    }
+    /** Aggiunge una nuova istanza vuota a una sezione repeatable. */
+    addRepeatableInstance(sectionId) {
+        if (!this.canAddInstance(sectionId))
+            return;
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section)
+            return;
+        const arr = this.getRepeatableArray(sectionId);
+        arr.push(this.buildInstanceFormGroup(section));
+        this.rebuildRepeatableAccordion(section);
+        this.cdr.markForCheck();
+    }
+    /** Rimuove un'istanza da una sezione repeatable. */
+    removeRepeatableInstance(sectionId, index) {
+        if (!this.canRemoveInstance(sectionId))
+            return;
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section?.repeatable)
+            return;
+        if (section.repeatable.confirmRemove) {
+            const msg = section.repeatable.confirmMessage ?? 'Sei sicuro di voler rimuovere questa sezione?';
+            if (!confirm(msg))
+                return;
+        }
+        const arr = this.getRepeatableArray(sectionId);
+        arr.removeAt(index);
+        this.rebuildRepeatableAccordion(section);
+        this.cdr.markForCheck();
+    }
+    /** Duplica un'istanza esistente con i suoi valori. */
+    duplicateRepeatableInstance(sectionId, index) {
+        if (!this.canAddInstance(sectionId))
+            return;
+        const section = this.schema.sections.find((s) => s.id === sectionId);
+        if (!section)
+            return;
+        const arr = this.getRepeatableArray(sectionId);
+        const sourceData = arr.at(index).getRawValue();
+        const newGroup = this.buildInstanceFormGroup(section, sourceData);
+        arr.insert(index + 1, newGroup);
+        this.rebuildRepeatableAccordion(section);
+        this.cdr.markForCheck();
+    }
+    /** Titolo di un'istanza repeatable. */
+    getInstanceTitle(section, index) {
+        const template = section.repeatable?.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');
+        return template.replace('{index}', String(index + 1));
+    }
+    /** Scrolla al campo e lo evidenzia. */
+    scrollToField(fieldKey) {
+        const control = this.formGroup.get(fieldKey);
+        if (control) {
+            control.markAsTouched();
+            control.markAsDirty();
+            control.updateValueAndValidity();
+        }
+        setTimeout(() => {
+            const selectors = [`[data-field-key="${fieldKey}"]`, `[formControlName="${fieldKey}"]`];
+            let targetElement = null;
+            for (const sel of selectors) {
+                targetElement = this.elRef.nativeElement.querySelector(sel);
+                if (targetElement)
+                    break;
+            }
+            if (!targetElement)
+                return;
+            // Se trovato il formControlName, risali al wrapper
+            if (targetElement.hasAttribute('formControlName')) {
+                const wrapper = targetElement.closest('.ui-form-builder__field-wrapper, mat-form-field');
+                if (wrapper)
+                    targetElement = wrapper;
+            }
+            targetElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
+            // Aggiungi classe highlight e rimuovila dopo l'animazione
+            targetElement.classList.add('ui-form-field--highlight');
+            setTimeout(() => targetElement.classList.remove('ui-form-field--highlight'), 2000);
+        }, 100);
+    }
+    /** Submit del form. */
+    onSubmit() {
+        this.validateAllFields();
+        const formValue = this.getFormValue();
+        const isValid = this.formGroup.valid;
+        this.logger?.logFormAction('submit', {
+            schemaId: this.schema?.id ?? 'unknown',
+            valid: isValid,
+            fieldCount: Object.keys(formValue).length,
+        });
+        if (isValid) {
+            this.formSubmit.emit(formValue);
+        }
+    }
+    /** Reset del form. */
+    onReset() {
+        // Resetta campi piatti
+        for (const field of this.allFlatFields) {
+            const value = this.initialData?.[field.key] ?? field.defaultValue ?? null;
+            const control = this.formGroup.get(field.key);
+            control?.setValue(value, { emitEvent: false });
+            control?.markAsPristine();
+            control?.markAsUntouched();
+        }
+        // Resetta sezioni repeatable
+        for (const section of this.repeatableSections) {
+            const arr = this.getRepeatableArray(section.id);
+            if (!arr)
+                continue;
+            const initialArray = this.initialData?.[section.id];
+            const count = this.getRepeatableInitialInstanceCount(section);
+            arr.clear();
+            for (let i = 0; i < count; i++) {
+                arr.push(this.buildInstanceFormGroup(section, initialArray?.[i]));
+            }
+            this.rebuildRepeatableAccordion(section);
+        }
+        this.formGroup.updateValueAndValidity();
+        this.formReset.emit();
+        this.cdr.markForCheck();
+    }
+    // ─── Template helpers ───────────────────────────────────────────
+    /** Opzioni per un campo (filtrando per autocomplete query). */
+    getFieldOptions(field) {
+        return this.filteredOptions[field.key] || [];
+    }
+    /** Filtra opzioni per autocomplete. */
+    filterOptions(field, query) {
+        if (!query) {
+            if (field.options && !this.isObservable(field.options)) {
+                this.filteredOptions[field.key] = [...field.options];
+            }
+            return;
+        }
+        const lowerQuery = query.toLowerCase();
+        if (field.asyncOptions) {
+            field.asyncOptions(query).then((opts) => {
+                this.filteredOptions[field.key] = opts;
+                this.cdr.markForCheck();
+            });
+        }
+        else if (field.options && !this.isObservable(field.options)) {
+            this.filteredOptions[field.key] = field.options.filter((o) => o.label.toLowerCase().includes(lowerQuery));
+        }
+    }
+    /** Display fn per autocomplete. */
+    displayFn(options) {
+        return (value) => {
+            const opt = options.find((o) => o.value === value);
+            return opt?.label || '';
+        };
+    }
+    /** Seleziona tutte le opzioni per multiselect. */
+    selectAll(field) {
+        const options = this.getFieldOptions(field);
+        const allValues = options.filter((o) => !o.disabled).map((o) => o.value);
+        this.formGroup.get(field.key)?.setValue(allValues);
+    }
+    /** Aggiunge un chip al freemultiselect (da token: Enter o virgola). */
+    addFreeChip(field, event) {
+        const value = (event.value || '').trim();
+        if (!value)
+            return;
+        const current = this.formGroup.get(field.key)?.value || [];
+        if (!current.includes(value)) {
+            this.formGroup.get(field.key)?.setValue([...current, value]);
+        }
+        event.chipInput?.clear();
+    }
+    /** Aggiunge un chip al freemultiselect sull'evento blur dell'input. */
+    addFreeChipOnBlur(field, event) {
+        const input = event.target;
+        const value = (input.value || '').trim();
+        if (!value)
+            return;
+        const current = this.formGroup.get(field.key)?.value || [];
+        if (!current.includes(value)) {
+            this.formGroup.get(field.key)?.setValue([...current, value]);
+        }
+        input.value = '';
+    }
+    /** Rimuove un chip dal freemultiselect. */
+    removeFreeChip(field, chipValue) {
+        const current = this.formGroup.get(field.key)?.value || [];
+        const protected_ = field.metadata?.['cantDeleteList'] || [];
+        if (protected_.includes(chipValue))
+            return;
+        this.formGroup.get(field.key)?.setValue(current.filter((v) => v !== chipValue));
+    }
+    /** Verifica se un chip e protetto dalla cancellazione. */
+    isChipProtected(field, chipValue) {
+        return (field.metadata?.['cantDeleteList'] || []).includes(chipValue);
+    }
+    /** Rimuove chip da multiselect. */
+    removeMultiselectChip(field, chipValue) {
+        const current = this.formGroup.get(field.key)?.value || [];
+        this.formGroup.get(field.key)?.setValue(current.filter((v) => v !== chipValue));
+    }
+    /** Trova label di un'opzione dal valore. */
+    getOptionLabel(field, value) {
+        const options = this.getFieldOptions(field);
+        return options.find((o) => o.value === value)?.label || String(value);
+    }
+    /** Tipo di input nativo per il campo. */
+    getNativeInputType(field) {
+        switch (field.type) {
+            case 'password':
+                return 'password';
+            case 'email':
+                return 'email';
+            default:
+                return 'text';
+        }
+    }
+    /**
+     * 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) {
+        const classes = [];
+        if (field.cssClasses?.length) {
+            classes.push(...field.cssClasses);
+        }
+        // layout.columns → classe per il breakpoint md (default desktop)
+        if (field.layout?.columns) {
+            classes.push(`ui-col-md-${field.layout.columns}`);
+        }
+        // layout.breakpoints → classi per breakpoint specifici
+        if (field.layout?.breakpoints) {
+            for (const [bp, cols] of Object.entries(field.layout.breakpoints)) {
+                classes.push(`ui-col-${bp}-${cols}`);
+            }
+        }
+        return classes.join(' ');
+    }
+    /** Character count per textarea/text con maxLength. */
+    getCharCount(fieldKey, fg) {
+        const field = this.allFields.find((f) => f.key === fieldKey);
+        const maxLength = this.fieldErrorService.resolveMaxLength(field?.validation);
+        if (maxLength == null)
+            return null;
+        const target = fg || this.formGroup;
+        return this.fieldErrorService.getCharCount(target.get(fieldKey), maxLength);
+    }
+    // ─── Utilita private ────────────────────────────────────────────
+    isObservable(value) {
+        return value && typeof value.subscribe === 'function';
+    }
+    getRepeatableAddButtons(section) {
+        return [{
+                label: section.repeatable?.addLabel || '+ Aggiungi',
+                icon: section.repeatable?.addIcon || 'plus',
+                variant: 'outline',
+                action: () => this.addRepeatableInstance(section.id)
+            }];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormBuilderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiFormBuilderComponent, isStandalone: true, selector: "ui-form-builder", inputs: { schema: "schema", initialData: "initialData", readonly: "readonly", disabled: "disabled", buttonsOverride: "buttonsOverride", loadingFor: "loadingFor", customFieldTemplates: "customFieldTemplates", customFieldTemplateFallback: "customFieldTemplateFallback" }, outputs: { valueChange: "valueChange", validationChange: "validationChange", formSubmit: "formSubmit", formReset: "formReset", customEvent: "customEvent" }, host: { classAttribute: "ui-form-builder-host" }, providers: [
+            { provide: ErrorStateMatcher, useClass: UiFormErrorStateMatcher },
+            // Locale italiano per il datepicker Material
+            { provide: MAT_DATE_LOCALE, useValue: 'it-IT' },
+            // Adapter personalizzato per parsing DD/MM/YYYY
+            { provide: DateAdapter, useClass: UiItalianDateAdapter },
+            // Formati data italiani (DD/MM/YYYY)
+            { provide: MAT_DATE_FORMATS, useValue: UI_IT_DATE_FORMATS },
+        ], usesOnChanges: true, ngImport: i0, template: "<!--\r\n  ============================================================\r\n  UI FORM BUILDER - TEMPLATE PRINCIPALE\r\n  ============================================================\r\n  ARCHITETTURA:\r\n  Ogni <ng-template> che contiene direttive [formControlName]\r\n  DEVE wrappare il proprio contenuto in un <div [formGroup]>.\r\n  Questo perche Angular risolve l'injector di formControlName\r\n  dal CONTESTO DI DICHIARAZIONE del template, non dal punto\r\n  di inserimento (ngTemplateOutlet).\r\n\r\n  Il FormGroup viene passato tramite context per supportare\r\n  sia campi piatti (root FormGroup) che campi in istanze\r\n  repeatable (instance FormGroup).\r\n\r\n  Senza questo wrapper, formControlName non trova il\r\n  FormGroupDirective e lancia NG01050.\r\n  ============================================================\r\n-->\r\n\r\n@if (schema && formGroup) {\r\n<div class=\"ui-form-builder\" [formGroup]=\"formGroup\" [class]=\"schema.config?.cssClasses?.join(' ')\">\r\n\r\n  <!-- ==================== HEADER ==================== -->\r\n  @if (schema.title || schema.description) {\r\n  <div class=\"ui-form-builder__header\">\r\n    @if (schema.title) {\r\n    <h2 class=\"ui-form-builder__title\">{{ schema.title }}</h2>\r\n    }\r\n    @if (schema.description) {\r\n    <p class=\"ui-form-builder__description\">{{ schema.description }}</p>\r\n    }\r\n  </div>\r\n  }\r\n\r\n  <!-- ==================== SEZIONI ==================== -->\r\n  <div class=\"ui-form-builder__sections\">\r\n    @for (section of schema.sections; track section.id) {\r\n    @if (isSectionVisible(section.id)) {\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione REPEATABLE \u2500\u2500\u2500 -->\r\n    @if (section.repeatable) {\r\n    <div class=\"ui-form-builder__section ui-form-builder__section--repeatable\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <ui-accordion [items]=\"getRepeatableAccordionItems(section.id)\" [itemTemplate]=\"repeatableBodyTpl\"\r\n        [actionsTemplate]=\"repeatableActionsTpl\" mode=\"multi\" class=\"ui-form-builder__repeatable-accordion\">\r\n        <!-- Contenuto di ogni istanza -->\r\n        <ng-template #repeatableBodyTpl let-item>\r\n          <div class=\"ui-form-builder__section-content\"\r\n            [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n            @for (field of section.fields; track field.key) {\r\n            @if (isFieldVisible(field.key, getInstanceFormGroup(section.id, item.index)!) && field.type !== 'flag') {\r\n            <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n              [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n              <ng-container\r\n                *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: getInstanceFormGroup(section.id, item.index), nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key, section.id + '[' + item.index + '].') }\" />\r\n            </div>\r\n            }\r\n            }\r\n          </div>\r\n        </ng-template>\r\n\r\n        <!-- Azioni per ogni istanza (duplica / elimina) -->\r\n        <ng-template #repeatableActionsTpl let-item>\r\n          @if (canAddInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action\"\r\n            (click)=\"duplicateRepeatableInstance(section.id, item.index)\" aria-label=\"Duplica\">\r\n            <lucide-icon name=\"copy\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n          @if (canRemoveInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action ui-form-builder__repeatable-action--danger\"\r\n            (click)=\"removeRepeatableInstance(section.id, item.index)\" aria-label=\"Elimina\">\r\n            <lucide-icon name=\"trash-2\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n        </ng-template>\r\n      </ui-accordion>\r\n\r\n      @if (canAddInstance(section.id)) {\r\n      <div class=\"ui-form-builder__repeatable-add\">\r\n        <ui-button-area [buttons]=\"getRepeatableAddButtons(section)\" align=\"end\" />\r\n      </div>\r\n      }\r\n    </div>\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione COLLASSABILE \u2500\u2500\u2500 -->\r\n    } @else if (section.collapsible) {\r\n    <ui-accordion [items]=\"getSectionAccordionItems(section.id)\" [itemTemplate]=\"collapsibleTpl\" mode=\"multi\"\r\n      class=\"ui-form-builder__section ui-form-builder__section--collapsible\" [class]=\"section.cssClasses?.join(' ')\">\r\n      <ng-template #collapsibleTpl let-item>\r\n        <div class=\"ui-form-builder__section-content\"\r\n          [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n          @for (field of section.fields; track field.key) {\r\n          @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n          <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n            [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n            <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n          </div>\r\n          }\r\n          }\r\n        </div>\r\n      </ng-template>\r\n    </ui-accordion>\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione STANDARD \u2500\u2500\u2500 -->\r\n    } @else {\r\n    <div class=\"ui-form-builder__section\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <div class=\"ui-form-builder__section-content\"\r\n        [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n        @for (field of section.fields; track field.key) {\r\n        @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n        <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n          [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n          <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n        </div>\r\n        }\r\n        }\r\n      </div>\r\n    </div>\r\n    }\r\n    }\r\n    }\r\n  </div>\r\n\r\n  <!-- ==================== FOOTER ==================== -->\r\n  <div class=\"ui-form-builder__footer\">\r\n    @if (!schema.config?.hideErrorSummary) {\r\n    <ui-form-error-summary [errors]=\"formErrors\" [totalErrorCount]=\"getFormErrorsCount()\"\r\n      [validMessage]=\"schema.config?.errorSummaryValidMessage ?? 'Il form \u00E8 compilato correttamente'\"\r\n      (fieldClick)=\"scrollToField($event)\" />\r\n    }\r\n    @if (!schema.config?.hideFooter) {\r\n    <ui-button-area [buttons]=\"formButtons\" align=\"end\" [loadingIds]=\"loadingFor\" />\r\n    }\r\n  </div>\r\n</div>\r\n}\r\n\r\n<!-- ============================================================ -->\r\n<!-- FIELD TEMPLATE                                                -->\r\n<!-- ============================================================ -->\r\n<!--\r\n  CRITICO: Questo template e dichiarato FUORI dal <div [formGroup]>.\r\n  Angular risolve l'injector dal contesto di DICHIARAZIONE.\r\n  Il FormGroup viene passato via context (fg) per supportare\r\n  sia il root FormGroup che i FormGroup delle istanze repeatable.\r\n-->\r\n<ng-template #fieldTpl let-field let-fg=\"formGroup\" let-nestedErrorKeyPrefix=\"nestedErrorKeyPrefix\">\r\n  @if (fg) {\r\n  <div [formGroup]=\"fg\" class=\"ui-fb-field-ctx\">\r\n    @switch (field.type) {\r\n\r\n    <!-- TEXT / EMAIL / PASSWORD -->\r\n    @case ('text') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n    @case ('email') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n    @case ('password') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- NUMBER -->\r\n    @case ('number') {\r\n      <ui-form-number-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- TEXTAREA -->\r\n    @case ('textarea') {\r\n      <ui-form-textarea-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- SELECT -->\r\n    @case ('select') {\r\n      <ui-form-select-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n\r\n    <!-- MULTISELECT -->\r\n    @case ('multiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-select [formControlName]=\"field.key\" multiple [placeholder]=\"field.placeholder || ''\">\r\n        @if (field.allowSelectAll) {\r\n        <mat-option (click)=\"selectAll(field)\" (keydown.enter)=\"selectAll(field)\" (keydown.space)=\"selectAll(field)\">\r\n          <em>Seleziona tutto</em>\r\n        </mat-option>\r\n        }\r\n        @for (opt of getFieldOptions(field); track opt.value) {\r\n        <mat-option [value]=\"opt.value\" [disabled]=\"opt.disabled\">\r\n          {{ opt.label }}\r\n        </mat-option>\r\n        }\r\n      </mat-select>\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    @if (fg.get(field.key)?.value?.length) {\r\n    <div class=\"ui-form-builder__chips-preview\">\r\n      @for (val of fg.get(field.key)!.value; track val) {\r\n      <span class=\"ui-form-builder__chip\">\r\n        {{ getOptionLabel(field, val) }}\r\n        <button type=\"button\" (click)=\"removeMultiselectChip(field, val)\" class=\"ui-form-builder__chip-remove\"\r\n          aria-label=\"Rimuovi\">\r\n          <lucide-icon name=\"x\" [size]=\"12\" />\r\n        </button>\r\n      </span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- FREEMULTISELECT -->\r\n    @case ('freemultiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width ui-form-builder__free-multi-field\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-chip-grid #chipGrid [formControlName]=\"field.key\">\r\n        @for (chip of fg.get(field.key)?.value || []; track chip) {\r\n        <mat-chip-row [removable]=\"!isChipProtected(field, chip)\" (removed)=\"removeFreeChip(field, chip)\">\r\n          {{ chip }}\r\n          @if (!isChipProtected(field, chip)) {\r\n          <button matChipRemove aria-label=\"Rimuovi\">\r\n            <lucide-icon name=\"x\" [size]=\"14\" />\r\n          </button>\r\n          }\r\n        </mat-chip-row>\r\n        }\r\n      </mat-chip-grid>\r\n      <input matInput [matChipInputFor]=\"chipGrid\" [placeholder]=\"field.placeholder || 'Aggiungi...'\"\r\n        [readonly]=\"field.readonly || readonly\" (matChipInputTokenEnd)=\"addFreeChip(field, $event)\"\r\n        (blur)=\"addFreeChipOnBlur(field, $event)\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- CHECKBOX -->\r\n    @case ('checkbox') {\r\n    @if (field.appearance?.style === 'switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n    </mat-slide-toggle>\r\n    } @else {\r\n    <mat-checkbox [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-checkbox>\r\n    }\r\n    @if (shouldShowFieldErrors(field.key, fg)) {\r\n    <div class=\"ui-form-builder__field-error\">\r\n      @for (err of getFieldErrors(field.key, fg); track $index) {\r\n      <span>{{ err }}</span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- SWITCH -->\r\n    @case ('switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-slide-toggle>\r\n    }\r\n\r\n    <!-- RADIO -->\r\n    @case ('radio') {\r\n      <ui-form-radio-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        [required]=\"isFieldRequired(field.key, fg)\"\r\n        [showErrors]=\"shouldShowFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- DATE -->\r\n    @case ('date') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput [matDatepicker]=\"datepicker\" [formControlName]=\"field.key\"\r\n        [placeholder]=\"field.placeholder || 'GG/MM/AAAA'\" [readonly]=\"field.readonly || readonly\" />\r\n      <mat-datepicker-toggle matSuffix [for]=\"datepicker\" />\r\n      <mat-datepicker #datepicker [startView]=\"field.customConfig?.config?.['monthView'] ? 'year' : 'month'\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- DATETIME -->\r\n    @case ('datetime') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput type=\"datetime-local\" [formControlName]=\"field.key\" [placeholder]=\"field.placeholder || ''\"\r\n        [readonly]=\"field.readonly || readonly\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- FILE -->\r\n    @case ('file') {\r\n    <div class=\"ui-form-builder__file-wrapper\">\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      <ui-file-input [formControlName]=\"field.key\" [config]=\"field.fileConfig\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- DIVIDER -->\r\n    @case ('divider') {\r\n    <div class=\"ui-form-builder__divider\">\r\n      @if (field.label) {\r\n      <span class=\"ui-form-builder__divider-label\">{{ field.label }}</span>\r\n      }\r\n      <hr class=\"ui-form-builder__divider-line\" />\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION (selezione territorio) -->\r\n    @case ('location') {\r\n    <div class=\"ui-form-builder__location-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-specifica-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-TABLE (tabella CRUD di location) -->\r\n    @case ('location-table') {\r\n    <div class=\"ui-form-builder__location-table-wrapper\">\r\n      <ui-table-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-GEOCODED (ricerca indirizzo Nominatim) -->\r\n    @case ('location-geocoded') {\r\n    <div class=\"ui-form-builder__location-geocoded-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\" [attr.for]=\"'ui-loc-' + field.key\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-location-geocoded [formControlName]=\"field.key\" [config]=\"field.locationGeocodedConfig || {}\"\r\n        [placeholder]=\"field.placeholder || 'Cerca indirizzo...'\"\r\n        [inputAriaLabel]=\"field.label || field.placeholder || 'Indirizzo'\"\r\n        [inputId]=\"'ui-loc-' + field.key\"\r\n        [readonly]=\"field.readonly || readonly\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- CUSTOM -->\r\n    @case ('custom') {\r\n    <div class=\"ui-form-builder__custom-wrapper\" [attr.data-component]=\"field.customConfig?.component\"\r\n      [attr.data-template-key]=\"resolveCustomTemplateKey(field)\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      @if (getCustomFieldOutlet(field, fg, nestedErrorKeyPrefix); as customOutlet) {\r\n      <ng-container *ngTemplateOutlet=\"customOutlet.template; context: customOutlet.context\" />\r\n      } @else {\r\n      <div class=\"ui-form-builder__custom-placeholder\" role=\"status\">\r\n        <span>Nessun template registrato per \u00AB{{ resolveCustomTemplateKey(field) }}\u00BB</span>\r\n      </div>\r\n      }\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n  </div>\r\n  }\r\n</ng-template>", styles: [".ui-form-builder{display:flex;flex-direction:column;gap:var(--ui-spacing-6);font-family:var(--ui-font-family)}.ui-form-builder__header{margin-bottom:var(--ui-spacing-2)}.ui-form-builder__title{font-size:var(--ui-font-size-xl);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text);margin:0 0 var(--ui-spacing-1)}.ui-form-builder__description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0}.ui-form-builder__sections{display:flex;flex-direction:column;gap:var(--ui-spacing-6)}.ui-form-builder__section--repeatable{display:flex;flex-direction:column;gap:var(--ui-spacing-4)}.ui-form-builder__repeatable-action{appearance:none;border:none;background:transparent;cursor:pointer;padding:var(--ui-spacing-1);border-radius:var(--ui-radius-sm);color:var(--ui-color-text-muted);display:inline-flex;align-items:center;justify-content:center;transition:color var(--ui-transition-fast),background-color var(--ui-transition-fast)}.ui-form-builder__repeatable-action:focus{outline:none}.ui-form-builder__repeatable-action:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-builder__repeatable-action:hover{color:var(--ui-color-text);background:var(--ui-color-surface-hover)}.ui-form-builder__repeatable-action--danger:hover{color:var(--ui-color-error, #dc2626);background:color-mix(in srgb,var(--ui-color-error, #dc2626) 8%,transparent)}.ui-form-builder__repeatable-add{display:flex;justify-content:flex-start;padding-top:var(--ui-spacing-2)}.ui-form-builder__section-header{margin-bottom:var(--ui-spacing-4);padding-bottom:var(--ui-spacing-2);border-bottom:1px solid var(--ui-color-border)}.ui-form-builder__section-title{font-size:var(--ui-font-size-lg);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text);margin:0 0 var(--ui-spacing-1)}.ui-form-builder__section-description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0}.ui-form-builder__grid{display:grid;grid-template-columns:repeat(12,1fr);gap:var(--ui-spacing-4) var(--ui-spacing-4);align-items:start}.ui-form-builder__field-wrapper{grid-column:span 12;min-width:0}@media (min-width: 768px){.ui-form-builder__field-wrapper{grid-column:span 6}}@media (min-width: 576px){.ui-form-builder__field-wrapper.ui-col-sm-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-sm-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-sm-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-sm-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-sm-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-sm-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-sm-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-sm-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-sm-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-sm-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-sm-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-sm-12{grid-column:span 12}}@media (min-width: 768px){.ui-form-builder__field-wrapper.ui-col-md-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-md-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-md-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-md-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-md-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-md-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-md-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-md-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-md-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-md-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-md-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-md-12{grid-column:span 12}}@media (min-width: 1024px){.ui-form-builder__field-wrapper.ui-col-lg-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-lg-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-lg-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-lg-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-lg-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-lg-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-lg-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-lg-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-lg-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-lg-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-lg-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-lg-12{grid-column:span 12}}@media (min-width: 1280px){.ui-form-builder__field-wrapper.ui-col-xl-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-xl-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-xl-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-xl-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-xl-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-xl-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-xl-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-xl-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-xl-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-xl-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-xl-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-xl-12{grid-column:span 12}}.ui-form-builder__full-width{width:100%}.ui-fb-field-ctx,.ui-fb-text-ctx{display:contents}.ui-form-builder__textarea-wrapper{position:relative}.ui-form-builder mat-hint.ui-form-builder__char-count{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted)}.ui-form-builder mat-hint.ui-form-builder__char-count.ui-form-builder__char-count--warn{color:var(--ui-color-warn, #d97706)}.ui-form-builder mat-hint.ui-form-builder__char-count.ui-form-builder__char-count--error{color:var(--ui-color-error, #dc2626);font-weight:var(--ui-font-weight-semibold)}.ui-form-builder__field-label{display:block;font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text);margin-bottom:var(--ui-spacing-4)}.ui-form-builder__required{color:var(--ui-color-error, #dc2626);margin-left:2px}.ui-form-builder__field-error{margin-top:var(--ui-spacing-1);font-size:var(--ui-font-size-xs);color:var(--ui-color-error, #dc2626);display:flex;flex-direction:column;gap:2px}.ui-form-builder__radio-wrapper mat-radio-group{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-3)}.ui-form-builder__chips-preview{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-1);margin-top:var(--ui-spacing-1)}.ui-form-builder__chip{display:inline-flex;align-items:center;gap:4px;padding:2px var(--ui-spacing-2);border-radius:var(--ui-radius-full);background:var(--ui-color-primary-subtle, rgba(37, 99, 235, .08));color:var(--ui-color-primary);font-size:var(--ui-font-size-xs)}.ui-form-builder__chip-remove{appearance:none;border:none;background:transparent;cursor:pointer;padding:0;display:flex;color:inherit;opacity:.7}.ui-form-builder__chip-remove:hover{opacity:1}.ui-form-builder__option-icon{margin-right:var(--ui-spacing-2);vertical-align:middle}.ui-form-builder__option-info{margin-left:auto;color:var(--ui-color-text-muted)}.ui-form-builder__inline-tooltip{margin-left:var(--ui-spacing-1);color:var(--ui-color-text-muted);cursor:help}.ui-form-builder__divider{grid-column:1/-1!important;display:flex;align-items:center;gap:var(--ui-spacing-3);padding:var(--ui-spacing-2) 0}.ui-form-builder__divider-label{font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text-secondary);white-space:nowrap}.ui-form-builder__divider-line{flex:1;border:none;border-top:1px solid var(--ui-color-border);margin:0}.ui-form-builder__custom-placeholder{display:flex;align-items:center;gap:var(--ui-spacing-2);padding:var(--ui-spacing-4);border:1px dashed var(--ui-color-border);border-radius:var(--ui-radius-md);color:var(--ui-color-text-muted);font-size:var(--ui-font-size-sm)}.ui-form-builder__footer{display:flex;align-items:center;justify-content:space-between;gap:var(--ui-spacing-4);padding-top:var(--ui-spacing-4);border-top:1px solid var(--ui-color-border)}@media (max-width: 767.98px){.ui-form-builder__footer{flex-direction:column;align-items:stretch}}.ui-form-field--highlight{animation:ui-field-highlight-pulse 1s ease-in-out 2;border-radius:var(--ui-radius-md)}@keyframes ui-field-highlight-pulse{0%{box-shadow:0 0 #dc262666;padding:10px}50%{box-shadow:0 0 0 6px #dc262626;padding:10px}to{box-shadow:0 0 #dc262600;padding:10px}}.ui-form-builder mat-error{font-size:var(--ui-font-size-xs, 12px);display:flex;flex-direction:column;transform:translateY(-5px)}.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__leading,.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__notch,.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__trailing{border-color:var(--ui-color-error, #dc2626)!important}.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mat-mdc-floating-label{color:var(--ui-color-error, #dc2626)}.ui-form-builder__free-multi-field mat-chip-grid{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-1)}.ui-form-builder__free-multi-field input[matInput]{flex:1;min-width:80px}.ui-form-builder mat-datepicker-toggle{display:inline-flex;align-items:center}.mdc-notched-outline__notch{border-left:none!important}\n"], dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "directive", type: i2.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i2.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i4.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i5.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "ngmodule", type: MatCheckboxModule }, { kind: "component", type: i6.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "disabledInteractive", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i7.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon", "disabledInteractive"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "ngmodule", type: MatRadioModule }, { kind: "ngmodule", type: MatDatepickerModule }, { kind: "component", type: i8.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i8.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { kind: "component", type: i8.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "ngmodule", type: MatNativeDateModule }, { kind: "ngmodule", type: MatAutocompleteModule }, { kind: "ngmodule", type: MatChipsModule }, { kind: "component", type: i9.MatChipGrid, selector: "mat-chip-grid", inputs: ["disabled", "placeholder", "required", "value", "errorStateMatcher"], outputs: ["change", "valueChange"] }, { kind: "directive", type: i9.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { kind: "directive", type: i9.MatChipRemove, selector: "[matChipRemove]" }, { kind: "component", type: i9.MatChipRow, selector: "mat-chip-row, [mat-chip-row], mat-basic-chip-row, [mat-basic-chip-row]", inputs: ["editable"], outputs: ["edited"] }, { kind: "component", type: UiAccordionComponent, selector: "ui-accordion", inputs: ["items", "itemTemplate", "headerTemplate", "actionsTemplate", "mode", "ariaLabel"], outputs: ["itemToggled"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i10.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i11.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }, { kind: "component", type: UiButtonAreaComponent, selector: "ui-button-area", inputs: ["buttons", "align", "ariaLabel", "gap", "stackOnMobile", "disableWhileLoading", "loadingIds"] }, { kind: "component", type: UiFormErrorSummaryComponent, selector: "ui-form-error-summary", inputs: ["errors", "totalErrorCount", "validMessage"], outputs: ["fieldClick"] }, { kind: "component", type: UiFileInputComponent, selector: "ui-file-input", inputs: ["config"], outputs: ["fileRemoved", "validationError"] }, { kind: "component", type: UiSpecificaTerritorialeComponent, selector: "ui-specifica-territoriale", inputs: ["config", "disabled"] }, { kind: "component", type: UiTableTerritorialeComponent, selector: "ui-table-territoriale", inputs: ["config", "disabled"] }, { kind: "component", type: UiLocationGeocodedComponent, selector: "ui-location-geocoded", inputs: ["config", "placeholder", "inputAriaLabel", "inputId", "disabled", "readonly"] }, { kind: "component", type: UiFormTextFieldComponent, selector: "ui-form-text-field", inputs: ["field", "formGroup", "readonly", "errors", "control", "label", "placeholder", "maxLength", "inputType", "validationRules", "options"], outputs: ["optionsFilter", "blurred"] }, { kind: "component", type: UiFormTextareaFieldComponent, selector: "ui-form-textarea-field", inputs: ["field", "formGroup", "readonly", "errors", "control", "label", "placeholder", "rows", "maxLength", "validationRules"], outputs: ["blurred"] }, { kind: "component", type: UiFormNumberFieldComponent, selector: "ui-form-number-field", inputs: ["field", "formGroup", "readonly", "errors", "control", "label", "placeholder", "validationRules", "currencyMode", "currencySymbol", "decimalPlaces"], outputs: ["blurred"] }, { kind: "component", type: UiFormSelectFieldComponent, selector: "ui-form-select-field", inputs: ["field", "formGroup", "readonly", "errors", "options", "control", "label", "placeholder", "searchable", "hideEmptyOption", "validationRules"], outputs: ["optionsFilter", "blurred"] }, { kind: "component", type: UiFormRadioFieldComponent, selector: "ui-form-radio-field", inputs: ["field", "formGroup", "readonly", "errors", "options", "required", "showErrors", "errorDisplayOptions", "control", "label", "validationRules", "color"], outputs: ["blurred"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormBuilderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-form-builder', standalone: true, imports: [
+                        ReactiveFormsModule,
+                        NgTemplateOutlet,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatSelectModule,
+                        MatCheckboxModule,
+                        MatSlideToggleModule,
+                        MatRadioModule,
+                        MatDatepickerModule,
+                        MatNativeDateModule,
+                        MatAutocompleteModule,
+                        MatChipsModule,
+                        UiAccordionComponent,
+                        MatTooltipModule,
+                        LucideAngularModule,
+                        UiButtonComponent,
+                        UiButtonAreaComponent,
+                        UiFormErrorSummaryComponent,
+                        UiFileInputComponent,
+                        UiSpecificaTerritorialeComponent,
+                        UiTableTerritorialeComponent,
+                        UiLocationGeocodedComponent,
+                        UiFormTextFieldComponent,
+                        UiFormTextareaFieldComponent,
+                        UiFormNumberFieldComponent,
+                        UiFormSelectFieldComponent,
+                        UiFormRadioFieldComponent,
+                    ], providers: [
+                        { provide: ErrorStateMatcher, useClass: UiFormErrorStateMatcher },
+                        // Locale italiano per il datepicker Material
+                        { provide: MAT_DATE_LOCALE, useValue: 'it-IT' },
+                        // Adapter personalizzato per parsing DD/MM/YYYY
+                        { provide: DateAdapter, useClass: UiItalianDateAdapter },
+                        // Formati data italiani (DD/MM/YYYY)
+                        { provide: MAT_DATE_FORMATS, useValue: UI_IT_DATE_FORMATS },
+                    ], encapsulation: ViewEncapsulation.None, host: { class: 'ui-form-builder-host' }, template: "<!--\r\n  ============================================================\r\n  UI FORM BUILDER - TEMPLATE PRINCIPALE\r\n  ============================================================\r\n  ARCHITETTURA:\r\n  Ogni <ng-template> che contiene direttive [formControlName]\r\n  DEVE wrappare il proprio contenuto in un <div [formGroup]>.\r\n  Questo perche Angular risolve l'injector di formControlName\r\n  dal CONTESTO DI DICHIARAZIONE del template, non dal punto\r\n  di inserimento (ngTemplateOutlet).\r\n\r\n  Il FormGroup viene passato tramite context per supportare\r\n  sia campi piatti (root FormGroup) che campi in istanze\r\n  repeatable (instance FormGroup).\r\n\r\n  Senza questo wrapper, formControlName non trova il\r\n  FormGroupDirective e lancia NG01050.\r\n  ============================================================\r\n-->\r\n\r\n@if (schema && formGroup) {\r\n<div class=\"ui-form-builder\" [formGroup]=\"formGroup\" [class]=\"schema.config?.cssClasses?.join(' ')\">\r\n\r\n  <!-- ==================== HEADER ==================== -->\r\n  @if (schema.title || schema.description) {\r\n  <div class=\"ui-form-builder__header\">\r\n    @if (schema.title) {\r\n    <h2 class=\"ui-form-builder__title\">{{ schema.title }}</h2>\r\n    }\r\n    @if (schema.description) {\r\n    <p class=\"ui-form-builder__description\">{{ schema.description }}</p>\r\n    }\r\n  </div>\r\n  }\r\n\r\n  <!-- ==================== SEZIONI ==================== -->\r\n  <div class=\"ui-form-builder__sections\">\r\n    @for (section of schema.sections; track section.id) {\r\n    @if (isSectionVisible(section.id)) {\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione REPEATABLE \u2500\u2500\u2500 -->\r\n    @if (section.repeatable) {\r\n    <div class=\"ui-form-builder__section ui-form-builder__section--repeatable\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <ui-accordion [items]=\"getRepeatableAccordionItems(section.id)\" [itemTemplate]=\"repeatableBodyTpl\"\r\n        [actionsTemplate]=\"repeatableActionsTpl\" mode=\"multi\" class=\"ui-form-builder__repeatable-accordion\">\r\n        <!-- Contenuto di ogni istanza -->\r\n        <ng-template #repeatableBodyTpl let-item>\r\n          <div class=\"ui-form-builder__section-content\"\r\n            [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n            @for (field of section.fields; track field.key) {\r\n            @if (isFieldVisible(field.key, getInstanceFormGroup(section.id, item.index)!) && field.type !== 'flag') {\r\n            <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n              [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n              <ng-container\r\n                *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: getInstanceFormGroup(section.id, item.index), nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key, section.id + '[' + item.index + '].') }\" />\r\n            </div>\r\n            }\r\n            }\r\n          </div>\r\n        </ng-template>\r\n\r\n        <!-- Azioni per ogni istanza (duplica / elimina) -->\r\n        <ng-template #repeatableActionsTpl let-item>\r\n          @if (canAddInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action\"\r\n            (click)=\"duplicateRepeatableInstance(section.id, item.index)\" aria-label=\"Duplica\">\r\n            <lucide-icon name=\"copy\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n          @if (canRemoveInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action ui-form-builder__repeatable-action--danger\"\r\n            (click)=\"removeRepeatableInstance(section.id, item.index)\" aria-label=\"Elimina\">\r\n            <lucide-icon name=\"trash-2\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n        </ng-template>\r\n      </ui-accordion>\r\n\r\n      @if (canAddInstance(section.id)) {\r\n      <div class=\"ui-form-builder__repeatable-add\">\r\n        <ui-button-area [buttons]=\"getRepeatableAddButtons(section)\" align=\"end\" />\r\n      </div>\r\n      }\r\n    </div>\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione COLLASSABILE \u2500\u2500\u2500 -->\r\n    } @else if (section.collapsible) {\r\n    <ui-accordion [items]=\"getSectionAccordionItems(section.id)\" [itemTemplate]=\"collapsibleTpl\" mode=\"multi\"\r\n      class=\"ui-form-builder__section ui-form-builder__section--collapsible\" [class]=\"section.cssClasses?.join(' ')\">\r\n      <ng-template #collapsibleTpl let-item>\r\n        <div class=\"ui-form-builder__section-content\"\r\n          [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n          @for (field of section.fields; track field.key) {\r\n          @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n          <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n            [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n            <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n          </div>\r\n          }\r\n          }\r\n        </div>\r\n      </ng-template>\r\n    </ui-accordion>\r\n\r\n    <!-- \u2500\u2500\u2500 Sezione STANDARD \u2500\u2500\u2500 -->\r\n    } @else {\r\n    <div class=\"ui-form-builder__section\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <div class=\"ui-form-builder__section-content\"\r\n        [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n        @for (field of section.fields; track field.key) {\r\n        @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n        <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n          [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n          <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n        </div>\r\n        }\r\n        }\r\n      </div>\r\n    </div>\r\n    }\r\n    }\r\n    }\r\n  </div>\r\n\r\n  <!-- ==================== FOOTER ==================== -->\r\n  <div class=\"ui-form-builder__footer\">\r\n    @if (!schema.config?.hideErrorSummary) {\r\n    <ui-form-error-summary [errors]=\"formErrors\" [totalErrorCount]=\"getFormErrorsCount()\"\r\n      [validMessage]=\"schema.config?.errorSummaryValidMessage ?? 'Il form \u00E8 compilato correttamente'\"\r\n      (fieldClick)=\"scrollToField($event)\" />\r\n    }\r\n    @if (!schema.config?.hideFooter) {\r\n    <ui-button-area [buttons]=\"formButtons\" align=\"end\" [loadingIds]=\"loadingFor\" />\r\n    }\r\n  </div>\r\n</div>\r\n}\r\n\r\n<!-- ============================================================ -->\r\n<!-- FIELD TEMPLATE                                                -->\r\n<!-- ============================================================ -->\r\n<!--\r\n  CRITICO: Questo template e dichiarato FUORI dal <div [formGroup]>.\r\n  Angular risolve l'injector dal contesto di DICHIARAZIONE.\r\n  Il FormGroup viene passato via context (fg) per supportare\r\n  sia il root FormGroup che i FormGroup delle istanze repeatable.\r\n-->\r\n<ng-template #fieldTpl let-field let-fg=\"formGroup\" let-nestedErrorKeyPrefix=\"nestedErrorKeyPrefix\">\r\n  @if (fg) {\r\n  <div [formGroup]=\"fg\" class=\"ui-fb-field-ctx\">\r\n    @switch (field.type) {\r\n\r\n    <!-- TEXT / EMAIL / PASSWORD -->\r\n    @case ('text') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n    @case ('email') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n    @case ('password') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- NUMBER -->\r\n    @case ('number') {\r\n      <ui-form-number-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- TEXTAREA -->\r\n    @case ('textarea') {\r\n      <ui-form-textarea-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- SELECT -->\r\n    @case ('select') {\r\n      <ui-form-select-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n\r\n    <!-- MULTISELECT -->\r\n    @case ('multiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-select [formControlName]=\"field.key\" multiple [placeholder]=\"field.placeholder || ''\">\r\n        @if (field.allowSelectAll) {\r\n        <mat-option (click)=\"selectAll(field)\" (keydown.enter)=\"selectAll(field)\" (keydown.space)=\"selectAll(field)\">\r\n          <em>Seleziona tutto</em>\r\n        </mat-option>\r\n        }\r\n        @for (opt of getFieldOptions(field); track opt.value) {\r\n        <mat-option [value]=\"opt.value\" [disabled]=\"opt.disabled\">\r\n          {{ opt.label }}\r\n        </mat-option>\r\n        }\r\n      </mat-select>\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    @if (fg.get(field.key)?.value?.length) {\r\n    <div class=\"ui-form-builder__chips-preview\">\r\n      @for (val of fg.get(field.key)!.value; track val) {\r\n      <span class=\"ui-form-builder__chip\">\r\n        {{ getOptionLabel(field, val) }}\r\n        <button type=\"button\" (click)=\"removeMultiselectChip(field, val)\" class=\"ui-form-builder__chip-remove\"\r\n          aria-label=\"Rimuovi\">\r\n          <lucide-icon name=\"x\" [size]=\"12\" />\r\n        </button>\r\n      </span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- FREEMULTISELECT -->\r\n    @case ('freemultiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width ui-form-builder__free-multi-field\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-chip-grid #chipGrid [formControlName]=\"field.key\">\r\n        @for (chip of fg.get(field.key)?.value || []; track chip) {\r\n        <mat-chip-row [removable]=\"!isChipProtected(field, chip)\" (removed)=\"removeFreeChip(field, chip)\">\r\n          {{ chip }}\r\n          @if (!isChipProtected(field, chip)) {\r\n          <button matChipRemove aria-label=\"Rimuovi\">\r\n            <lucide-icon name=\"x\" [size]=\"14\" />\r\n          </button>\r\n          }\r\n        </mat-chip-row>\r\n        }\r\n      </mat-chip-grid>\r\n      <input matInput [matChipInputFor]=\"chipGrid\" [placeholder]=\"field.placeholder || 'Aggiungi...'\"\r\n        [readonly]=\"field.readonly || readonly\" (matChipInputTokenEnd)=\"addFreeChip(field, $event)\"\r\n        (blur)=\"addFreeChipOnBlur(field, $event)\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- CHECKBOX -->\r\n    @case ('checkbox') {\r\n    @if (field.appearance?.style === 'switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n    </mat-slide-toggle>\r\n    } @else {\r\n    <mat-checkbox [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-checkbox>\r\n    }\r\n    @if (shouldShowFieldErrors(field.key, fg)) {\r\n    <div class=\"ui-form-builder__field-error\">\r\n      @for (err of getFieldErrors(field.key, fg); track $index) {\r\n      <span>{{ err }}</span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- SWITCH -->\r\n    @case ('switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-slide-toggle>\r\n    }\r\n\r\n    <!-- RADIO -->\r\n    @case ('radio') {\r\n      <ui-form-radio-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        [required]=\"isFieldRequired(field.key, fg)\"\r\n        [showErrors]=\"shouldShowFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- DATE -->\r\n    @case ('date') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput [matDatepicker]=\"datepicker\" [formControlName]=\"field.key\"\r\n        [placeholder]=\"field.placeholder || 'GG/MM/AAAA'\" [readonly]=\"field.readonly || readonly\" />\r\n      <mat-datepicker-toggle matSuffix [for]=\"datepicker\" />\r\n      <mat-datepicker #datepicker [startView]=\"field.customConfig?.config?.['monthView'] ? 'year' : 'month'\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- DATETIME -->\r\n    @case ('datetime') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput type=\"datetime-local\" [formControlName]=\"field.key\" [placeholder]=\"field.placeholder || ''\"\r\n        [readonly]=\"field.readonly || readonly\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- FILE -->\r\n    @case ('file') {\r\n    <div class=\"ui-form-builder__file-wrapper\">\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      <ui-file-input [formControlName]=\"field.key\" [config]=\"field.fileConfig\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- DIVIDER -->\r\n    @case ('divider') {\r\n    <div class=\"ui-form-builder__divider\">\r\n      @if (field.label) {\r\n      <span class=\"ui-form-builder__divider-label\">{{ field.label }}</span>\r\n      }\r\n      <hr class=\"ui-form-builder__divider-line\" />\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION (selezione territorio) -->\r\n    @case ('location') {\r\n    <div class=\"ui-form-builder__location-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-specifica-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-TABLE (tabella CRUD di location) -->\r\n    @case ('location-table') {\r\n    <div class=\"ui-form-builder__location-table-wrapper\">\r\n      <ui-table-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-GEOCODED (ricerca indirizzo Nominatim) -->\r\n    @case ('location-geocoded') {\r\n    <div class=\"ui-form-builder__location-geocoded-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\" [attr.for]=\"'ui-loc-' + field.key\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-location-geocoded [formControlName]=\"field.key\" [config]=\"field.locationGeocodedConfig || {}\"\r\n        [placeholder]=\"field.placeholder || 'Cerca indirizzo...'\"\r\n        [inputAriaLabel]=\"field.label || field.placeholder || 'Indirizzo'\"\r\n        [inputId]=\"'ui-loc-' + field.key\"\r\n        [readonly]=\"field.readonly || readonly\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- CUSTOM -->\r\n    @case ('custom') {\r\n    <div class=\"ui-form-builder__custom-wrapper\" [attr.data-component]=\"field.customConfig?.component\"\r\n      [attr.data-template-key]=\"resolveCustomTemplateKey(field)\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      @if (getCustomFieldOutlet(field, fg, nestedErrorKeyPrefix); as customOutlet) {\r\n      <ng-container *ngTemplateOutlet=\"customOutlet.template; context: customOutlet.context\" />\r\n      } @else {\r\n      <div class=\"ui-form-builder__custom-placeholder\" role=\"status\">\r\n        <span>Nessun template registrato per \u00AB{{ resolveCustomTemplateKey(field) }}\u00BB</span>\r\n      </div>\r\n      }\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n  </div>\r\n  }\r\n</ng-template>", styles: [".ui-form-builder{display:flex;flex-direction:column;gap:var(--ui-spacing-6);font-family:var(--ui-font-family)}.ui-form-builder__header{margin-bottom:var(--ui-spacing-2)}.ui-form-builder__title{font-size:var(--ui-font-size-xl);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text);margin:0 0 var(--ui-spacing-1)}.ui-form-builder__description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0}.ui-form-builder__sections{display:flex;flex-direction:column;gap:var(--ui-spacing-6)}.ui-form-builder__section--repeatable{display:flex;flex-direction:column;gap:var(--ui-spacing-4)}.ui-form-builder__repeatable-action{appearance:none;border:none;background:transparent;cursor:pointer;padding:var(--ui-spacing-1);border-radius:var(--ui-radius-sm);color:var(--ui-color-text-muted);display:inline-flex;align-items:center;justify-content:center;transition:color var(--ui-transition-fast),background-color var(--ui-transition-fast)}.ui-form-builder__repeatable-action:focus{outline:none}.ui-form-builder__repeatable-action:focus-visible{outline:var(--ui-focus-ring-width) solid var(--ui-focus-ring-color);outline-offset:var(--ui-focus-ring-offset)}.ui-form-builder__repeatable-action:hover{color:var(--ui-color-text);background:var(--ui-color-surface-hover)}.ui-form-builder__repeatable-action--danger:hover{color:var(--ui-color-error, #dc2626);background:color-mix(in srgb,var(--ui-color-error, #dc2626) 8%,transparent)}.ui-form-builder__repeatable-add{display:flex;justify-content:flex-start;padding-top:var(--ui-spacing-2)}.ui-form-builder__section-header{margin-bottom:var(--ui-spacing-4);padding-bottom:var(--ui-spacing-2);border-bottom:1px solid var(--ui-color-border)}.ui-form-builder__section-title{font-size:var(--ui-font-size-lg);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text);margin:0 0 var(--ui-spacing-1)}.ui-form-builder__section-description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0}.ui-form-builder__grid{display:grid;grid-template-columns:repeat(12,1fr);gap:var(--ui-spacing-4) var(--ui-spacing-4);align-items:start}.ui-form-builder__field-wrapper{grid-column:span 12;min-width:0}@media (min-width: 768px){.ui-form-builder__field-wrapper{grid-column:span 6}}@media (min-width: 576px){.ui-form-builder__field-wrapper.ui-col-sm-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-sm-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-sm-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-sm-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-sm-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-sm-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-sm-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-sm-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-sm-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-sm-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-sm-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-sm-12{grid-column:span 12}}@media (min-width: 768px){.ui-form-builder__field-wrapper.ui-col-md-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-md-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-md-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-md-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-md-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-md-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-md-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-md-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-md-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-md-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-md-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-md-12{grid-column:span 12}}@media (min-width: 1024px){.ui-form-builder__field-wrapper.ui-col-lg-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-lg-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-lg-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-lg-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-lg-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-lg-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-lg-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-lg-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-lg-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-lg-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-lg-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-lg-12{grid-column:span 12}}@media (min-width: 1280px){.ui-form-builder__field-wrapper.ui-col-xl-1{grid-column:span 1}.ui-form-builder__field-wrapper.ui-col-xl-2{grid-column:span 2}.ui-form-builder__field-wrapper.ui-col-xl-3{grid-column:span 3}.ui-form-builder__field-wrapper.ui-col-xl-4{grid-column:span 4}.ui-form-builder__field-wrapper.ui-col-xl-5{grid-column:span 5}.ui-form-builder__field-wrapper.ui-col-xl-6{grid-column:span 6}.ui-form-builder__field-wrapper.ui-col-xl-7{grid-column:span 7}.ui-form-builder__field-wrapper.ui-col-xl-8{grid-column:span 8}.ui-form-builder__field-wrapper.ui-col-xl-9{grid-column:span 9}.ui-form-builder__field-wrapper.ui-col-xl-10{grid-column:span 10}.ui-form-builder__field-wrapper.ui-col-xl-11{grid-column:span 11}.ui-form-builder__field-wrapper.ui-col-xl-12{grid-column:span 12}}.ui-form-builder__full-width{width:100%}.ui-fb-field-ctx,.ui-fb-text-ctx{display:contents}.ui-form-builder__textarea-wrapper{position:relative}.ui-form-builder mat-hint.ui-form-builder__char-count{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted)}.ui-form-builder mat-hint.ui-form-builder__char-count.ui-form-builder__char-count--warn{color:var(--ui-color-warn, #d97706)}.ui-form-builder mat-hint.ui-form-builder__char-count.ui-form-builder__char-count--error{color:var(--ui-color-error, #dc2626);font-weight:var(--ui-font-weight-semibold)}.ui-form-builder__field-label{display:block;font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text);margin-bottom:var(--ui-spacing-4)}.ui-form-builder__required{color:var(--ui-color-error, #dc2626);margin-left:2px}.ui-form-builder__field-error{margin-top:var(--ui-spacing-1);font-size:var(--ui-font-size-xs);color:var(--ui-color-error, #dc2626);display:flex;flex-direction:column;gap:2px}.ui-form-builder__radio-wrapper mat-radio-group{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-3)}.ui-form-builder__chips-preview{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-1);margin-top:var(--ui-spacing-1)}.ui-form-builder__chip{display:inline-flex;align-items:center;gap:4px;padding:2px var(--ui-spacing-2);border-radius:var(--ui-radius-full);background:var(--ui-color-primary-subtle, rgba(37, 99, 235, .08));color:var(--ui-color-primary);font-size:var(--ui-font-size-xs)}.ui-form-builder__chip-remove{appearance:none;border:none;background:transparent;cursor:pointer;padding:0;display:flex;color:inherit;opacity:.7}.ui-form-builder__chip-remove:hover{opacity:1}.ui-form-builder__option-icon{margin-right:var(--ui-spacing-2);vertical-align:middle}.ui-form-builder__option-info{margin-left:auto;color:var(--ui-color-text-muted)}.ui-form-builder__inline-tooltip{margin-left:var(--ui-spacing-1);color:var(--ui-color-text-muted);cursor:help}.ui-form-builder__divider{grid-column:1/-1!important;display:flex;align-items:center;gap:var(--ui-spacing-3);padding:var(--ui-spacing-2) 0}.ui-form-builder__divider-label{font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-medium);color:var(--ui-color-text-secondary);white-space:nowrap}.ui-form-builder__divider-line{flex:1;border:none;border-top:1px solid var(--ui-color-border);margin:0}.ui-form-builder__custom-placeholder{display:flex;align-items:center;gap:var(--ui-spacing-2);padding:var(--ui-spacing-4);border:1px dashed var(--ui-color-border);border-radius:var(--ui-radius-md);color:var(--ui-color-text-muted);font-size:var(--ui-font-size-sm)}.ui-form-builder__footer{display:flex;align-items:center;justify-content:space-between;gap:var(--ui-spacing-4);padding-top:var(--ui-spacing-4);border-top:1px solid var(--ui-color-border)}@media (max-width: 767.98px){.ui-form-builder__footer{flex-direction:column;align-items:stretch}}.ui-form-field--highlight{animation:ui-field-highlight-pulse 1s ease-in-out 2;border-radius:var(--ui-radius-md)}@keyframes ui-field-highlight-pulse{0%{box-shadow:0 0 #dc262666;padding:10px}50%{box-shadow:0 0 0 6px #dc262626;padding:10px}to{box-shadow:0 0 #dc262600;padding:10px}}.ui-form-builder mat-error{font-size:var(--ui-font-size-xs, 12px);display:flex;flex-direction:column;transform:translateY(-5px)}.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__leading,.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__notch,.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mdc-notched-outline__trailing{border-color:var(--ui-color-error, #dc2626)!important}.ui-form-builder .mat-mdc-form-field.mat-form-field-invalid .mat-mdc-floating-label{color:var(--ui-color-error, #dc2626)}.ui-form-builder__free-multi-field mat-chip-grid{display:flex;flex-wrap:wrap;gap:var(--ui-spacing-1)}.ui-form-builder__free-multi-field input[matInput]{flex:1;min-width:80px}.ui-form-builder mat-datepicker-toggle{display:inline-flex;align-items:center}.mdc-notched-outline__notch{border-left:none!important}\n"] }]
+        }], propDecorators: { schema: [{
+                type: Input
+            }], initialData: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], buttonsOverride: [{
+                type: Input
+            }], loadingFor: [{
+                type: Input
+            }], customFieldTemplates: [{
+                type: Input
+            }], customFieldTemplateFallback: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], validationChange: [{
+                type: Output
+            }], formSubmit: [{
+                type: Output
+            }], formReset: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-builder.component.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/form-builder.component.ts","../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/form-builder.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  Output,\r\n  EventEmitter,\r\n  OnInit,\r\n  OnChanges,\r\n  OnDestroy,\r\n  SimpleChanges,\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  ViewEncapsulation,\r\n  inject,\r\n  ElementRef,\r\n  TemplateRef,\r\n} from '@angular/core';\r\nimport {\r\n  FormGroup,\r\n  FormControl,\r\n  FormArray,\r\n  ReactiveFormsModule,\r\n  Validators,\r\n  AbstractControl,\r\n} from '@angular/forms';\r\nimport { NgTemplateOutlet } from '@angular/common';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport {\r\n  MatNativeDateModule,\r\n  DateAdapter,\r\n  MAT_DATE_FORMATS,\r\n  MAT_DATE_LOCALE,\r\n  ErrorStateMatcher,\r\n} from '@angular/material/core';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { UiAccordionComponent, UiAccordionDescriptor } from '../accordion/index';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { LucideAngularModule } from 'lucide-angular';\r\nimport { Subject, Subscription, Observable } from 'rxjs';\r\nimport { debounceTime, takeUntil, distinctUntilChanged, filter as rxFilter } from 'rxjs/operators';\r\nimport { UiButtonComponent, UiButtonDescriptor } from '../../components/button/index';\r\nimport { UiButtonAreaComponent } from '../../components/button/button-area.component';\r\nimport { UiBlackboxService } from '../blackbox/blackbox.service';\r\nimport { UiLoggerService } from '../../core/logging/logger.service';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { UiFormSchema, UiFormSection, UiFormData, UiFormCustomEvent, UiFormBuilderConfig, UiRepeatableConfig } from './types/schema.types';\r\nimport {\r\n  UiFormFieldDescriptor,\r\n  UiFieldOption,\r\n  UiFieldType,\r\n  UiCustomFieldTemplateContext,\r\n} from './types/field.types';\r\nimport {\r\n  UiFormValidationState,\r\n  UiFormErrorDetail,\r\n  UiValidationRule,\r\n  UI_FORM_NESTED_FIELD_ERRORS_KEY,\r\n} from './types/validation.types';\r\nimport { UiFieldCondition } from './types/condition.types';\r\nimport { UiFormConditionService } from './services/form-condition.service';\r\nimport { UiFormValidationService } from './services/form-validation.service';\r\nimport { UiFormFieldErrorService } from './services/form-field-error.service';\r\nimport { UiFormErrorSummaryComponent } from './sub-components/error-summary/form-error-summary.component';\r\nimport { UiFileInputComponent } from './sub-components/file-input/file-input.component';\r\nimport { UiSpecificaTerritorialeComponent } from './sub-components/specifica-territoriale/specifica-territoriale.component';\r\nimport { UiTableTerritorialeComponent } from './sub-components/table-territoriale/table-territoriale.component';\r\nimport { UiLocationGeocodedComponent } from './sub-components/location-geocoded/location-geocoded.component';\r\nimport { UiFormTextFieldComponent, UiFormTextareaFieldComponent, UiFormNumberFieldComponent, UiFormSelectFieldComponent, UiFormRadioFieldComponent } from './sub-components/form-fields/index';\r\nimport { UiFormErrorStateMatcher } from './services/form-error-state.matcher';\r\nimport { UiItalianDateAdapter, UI_IT_DATE_FORMATS } from './adapters/it-date-adapter';\r\n\r\n/**\r\n * Form builder data-driven e schema-based.\r\n *\r\n * Genera un form completo a partire da uno schema dichiarativo (`UiFormSchema`).\r\n * Supporta i tipi di campo del form builder, validazione condizionale, cross-field validation,\r\n * date con offset, opzioni dipendenti/dinamiche, sezioni collapsibili,\r\n * error summary con scroll-to-field e button override.\r\n *\r\n * @selector ui-form-builder\r\n *\r\n * @example\r\n * ```html\r\n * <ui-form-builder\r\n *   [schema]=\"formSchema\"\r\n *   [initialData]=\"userData\"\r\n *   (formSubmit)=\"onSubmit($event)\"\r\n *   (valueChange)=\"onChange($event)\"\r\n * />\r\n * ```\r\n */\r\n@Component({\r\n  selector: 'ui-form-builder',\r\n  standalone: true,\r\n  imports: [\r\n    ReactiveFormsModule,\r\n    NgTemplateOutlet,\r\n    MatFormFieldModule,\r\n    MatInputModule,\r\n    MatSelectModule,\r\n    MatCheckboxModule,\r\n    MatSlideToggleModule,\r\n    MatRadioModule,\r\n    MatDatepickerModule,\r\n    MatNativeDateModule,\r\n    MatAutocompleteModule,\r\n    MatChipsModule,\r\n    UiAccordionComponent,\r\n    MatTooltipModule,\r\n    LucideAngularModule,\r\n    UiButtonComponent,\r\n    UiButtonAreaComponent,\r\n    UiFormErrorSummaryComponent,\r\n    UiFileInputComponent,\r\n    UiSpecificaTerritorialeComponent,\r\n    UiTableTerritorialeComponent,\r\n    UiLocationGeocodedComponent,\r\n    UiFormTextFieldComponent,\r\n    UiFormTextareaFieldComponent,\r\n    UiFormNumberFieldComponent,\r\n    UiFormSelectFieldComponent,\r\n    UiFormRadioFieldComponent,\r\n  ],\r\n  providers: [\r\n    { provide: ErrorStateMatcher, useClass: UiFormErrorStateMatcher },\r\n    // Locale italiano per il datepicker Material\r\n    { provide: MAT_DATE_LOCALE, useValue: 'it-IT' },\r\n    // Adapter personalizzato per parsing DD/MM/YYYY\r\n    { provide: DateAdapter, useClass: UiItalianDateAdapter },\r\n    // Formati data italiani (DD/MM/YYYY)\r\n    { provide: MAT_DATE_FORMATS, useValue: UI_IT_DATE_FORMATS },\r\n  ],\r\n  encapsulation: ViewEncapsulation.None,\r\n  host: { class: 'ui-form-builder-host' },\r\n  templateUrl: './form-builder.component.html',\r\n  styleUrl: './form-builder.component.scss',\r\n})\r\nexport class UiFormBuilderComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {\r\n  private readonly cdr = inject(ChangeDetectorRef);\r\n  private readonly elRef = inject(ElementRef);\r\n  private readonly conditionService = inject(UiFormConditionService);\r\n  private readonly validationService = inject(UiFormValidationService);\r\n  private readonly fieldErrorService = inject(UiFormFieldErrorService);\r\n\r\n  /** @internal Optional BlackBox service — auto-tracks form events when available. */\r\n  private readonly blackbox = inject(UiBlackboxService, { optional: true });\r\n  /** @internal Router inject for BlackBox route context. */\r\n  private readonly bbRouter = inject(Router, { optional: true });\r\n  /** @internal Optional Logger service — logs form actions when available. */\r\n  private readonly logger = inject(UiLoggerService, { optional: true });\r\n\r\n  private readonly destroy$ = new Subject<void>();\r\n  private valueChangeSub?: Subscription;\r\n  /** @internal Listener cleanup for BlackBox focus/blur tracking. */\r\n  private bbFocusHandler: ((e: FocusEvent) => void) | null = null;\r\n  private bbBlurHandler: ((e: FocusEvent) => void) | null = null;\r\n\r\n  /** ID schema corrente -- usato per evitare rebuild superflui. */\r\n  private currentSchemaId: string | null = null;\r\n\r\n  // ─── Input ──────────────────────────────────────────────────────\r\n\r\n  /** Schema del form. */\r\n  @Input() schema!: UiFormSchema;\r\n\r\n  /** Dati iniziali per la prevalorizzazione. */\r\n  @Input() initialData: UiFormData = {};\r\n\r\n  /** Modalita sola lettura globale. */\r\n  @Input() readonly = false;\r\n\r\n  /** Stato disabilitato globale. */\r\n  @Input() disabled = false;\r\n\r\n  /** Override dei pulsanti di default. */\r\n  @Input() buttonsOverride?: UiButtonDescriptor[];\r\n\r\n  /** Chiave del pulsante in stato di caricamento. */\r\n  @Input() loadingFor: string | null = null;\r\n\r\n  /**\r\n   * Mappa chiave logica → template per campi `type: 'custom'`.\r\n   * La chiave si risolve con `customConfig.templateKey`, poi `customConfig.component`, poi `field.key`.\r\n   */\r\n  @Input() customFieldTemplates: Record<string, TemplateRef<unknown>> = {};\r\n\r\n  /**\r\n   * Template usato quando non esiste una voce in `customFieldTemplates` per la chiave risolta\r\n   * (es. un unico `ng-template` con `@switch` sul campo).\r\n   */\r\n  @Input() customFieldTemplateFallback?: TemplateRef<unknown>;\r\n\r\n  // ─── Output ─────────────────────────────────────────────────────\r\n\r\n  @Output() valueChange = new EventEmitter<UiFormData>();\r\n  @Output() validationChange = new EventEmitter<UiFormValidationState>();\r\n  @Output() formSubmit = new EventEmitter<UiFormData>();\r\n  @Output() formReset = new EventEmitter<void>();\r\n  @Output() customEvent = new EventEmitter<UiFormCustomEvent>();\r\n\r\n  // ─── Stato interno ──────────────────────────────────────────────\r\n\r\n  formGroup!: FormGroup;\r\n\r\n  /** Mappa campo -> opzioni filtrate (per autocomplete e dependent). */\r\n  filteredOptions: Record<string, UiFieldOption[]> = {};\r\n\r\n  /** Campi prevalorizzati (mostrano errori subito). */\r\n  prevalorizedFields = new Set<string>();\r\n\r\n  /** Mappa campo -> regole di validazione (per lookup rapido). */\r\n  private validationRulesMap: Record<string, UiValidationRule[]> = {};\r\n\r\n  /** Mappa dipendenze: campoTarget -> campi dipendenti. */\r\n  private fieldDependencies = new Map<string, Set<string>>();\r\n\r\n  /** @internal Accordion descriptors per le sezioni collapsibili. */\r\n  sectionAccordionMap = new Map<string, UiAccordionDescriptor[]>();\r\n\r\n  /** @internal Accordion descriptors per le istanze repeatable (sectionId -> descriptors). */\r\n  repeatableAccordionMap = new Map<string, UiAccordionDescriptor[]>();\r\n\r\n  /** Flag per evitare emissioni durante l'inizializzazione. */\r\n  private isInitializing = true;\r\n\r\n  // ─── Getter calcolati ───────────────────────────────────────────\r\n\r\n  /** Tutti i campi di tutte le sezioni (incluse repeatable). */\r\n  get allFields(): UiFormFieldDescriptor[] {\r\n    return this.schema?.sections?.flatMap((s) => s.fields) || [];\r\n  }\r\n\r\n  /** Campi delle sole sezioni non-repeatable (piatti nel root FormGroup). */\r\n  get allFlatFields(): UiFormFieldDescriptor[] {\r\n    return this.schema?.sections?.filter((s) => !s.repeatable).flatMap((s) => s.fields) || [];\r\n  }\r\n\r\n  /** Sezioni con configurazione repeatable. */\r\n  get repeatableSections(): UiFormSection[] {\r\n    return this.schema?.sections?.filter((s) => !!s.repeatable) || [];\r\n  }\r\n\r\n  get formErrors(): UiFormErrorDetail[] {\r\n    return this.getDetailedFormErrors();\r\n  }\r\n\r\n  get formButtons(): UiButtonDescriptor[] {\r\n    if (this.buttonsOverride) return this.buttonsOverride;\r\n    if (!this.schema?.config?.showButtons && this.schema?.config?.showButtons !== undefined) return [];\r\n    return [\r\n      { label: this.schema?.config?.buttonLabels?.reset || 'Reset', variant: 'outline', action: () => this.onReset() },\r\n      {\r\n        label: this.schema?.config?.buttonLabels?.submit || 'Invia',\r\n        variant: 'primary',\r\n        action: () => this.onSubmit(),\r\n      },\r\n    ];\r\n  }\r\n\r\n  // ─── Lifecycle ──────────────────────────────────────────────────\r\n  //\r\n  // ORDINE LIFECYCLE ANGULAR:\r\n  // 1. constructor\r\n  // 2. ngOnChanges (prima chiamata con valori iniziali)\r\n  // 3. ngOnInit\r\n  // 4. ngAfterViewInit\r\n  // 5. ngOnChanges (chiamate successive per cambio input)\r\n  //\r\n  // PER IL WIZARD:\r\n  // Il wizard crea un nuovo schema (con id diverso) ad ogni cambio step.\r\n  // Lo schema viene cachato nel wizard per evitare rebuild infiniti.\r\n  // ngOnChanges rileva il cambio di schema.id e ricostruisce il form.\r\n\r\n  ngOnInit(): void {\r\n    this.logger?.logFormAction('init', { schemaId: this.schema?.id ?? 'unknown', hasFormGroup: !!this.formGroup });\r\n    if (!this.schema) {\r\n      this.logger?.logFormAction('init', { schemaId: 'unknown', error: 'schema non presente' });\r\n      return;\r\n    }\r\n    this.initFormFromSchema();\r\n  }\r\n\r\n  /**\r\n   * Rileva cambiamenti sugli @Input.\r\n   * Ricostruisce il form quando cambia lo schema (id diverso).\r\n   * Cruciale per il wizard che cambia schema ad ogni step.\r\n   */\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['schema'] && !changes['schema'].firstChange) {\r\n      const newSchema = changes['schema'].currentValue as UiFormSchema;\r\n      if (newSchema && newSchema.id !== this.currentSchemaId) {\r\n        this.logger?.debug('form', 'schemaRebuild', {\r\n          schemaId: newSchema?.id,\r\n          previousSchemaId: this.currentSchemaId,\r\n        });\r\n        this.destroyForm();\r\n        this.initFormFromSchema();\r\n      }\r\n    }\r\n\r\n    // Aggiorna lo stato disabled/readonly globalmente\r\n    if (changes['disabled'] && !changes['disabled'].firstChange && this.formGroup) {\r\n      this.allFlatFields.forEach((field) => {\r\n        const control = this.formGroup.get(field.key);\r\n        if (!control) return;\r\n        if (this.disabled && control.enabled) {\r\n          control.disable({ emitEvent: false });\r\n        } else if (!this.disabled && control.disabled && !field.disabled) {\r\n          control.enable({ emitEvent: false });\r\n        }\r\n      });\r\n\r\n      // Aggiorna disabled anche nelle istanze repeatable\r\n      for (const section of this.repeatableSections) {\r\n        const arr = this.getRepeatableArray(section.id);\r\n        if (!arr) continue;\r\n        for (let i = 0; i < arr.length; i++) {\r\n          const instanceFg = arr.at(i) as FormGroup;\r\n          for (const field of section.fields) {\r\n            const control = instanceFg.get(field.key);\r\n            if (!control) continue;\r\n            if (this.disabled && control.enabled) {\r\n              control.disable({ emitEvent: false });\r\n            } else if (!this.disabled && control.disabled && !field.disabled) {\r\n              control.enable({ emitEvent: false });\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.logger?.debug('form', 'afterViewInit', {\r\n      schemaId: this.schema?.id,\r\n      hasFormGroup: !!this.formGroup,\r\n      fieldCount: this.formGroup ? Object.keys(this.formGroup.controls).length : 0,\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.logger?.logFormAction('destroy', { schemaId: this.currentSchemaId ?? 'unknown' });\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    this.valueChangeSub?.unsubscribe();\r\n\r\n    // BlackBox: cleanup DOM listeners\r\n    if (this.bbFocusHandler) {\r\n      this.elRef.nativeElement.removeEventListener('focusin', this.bbFocusHandler, true);\r\n    }\r\n    if (this.bbBlurHandler) {\r\n      this.elRef.nativeElement.removeEventListener('focusout', this.bbBlurHandler, true);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Inizializza il form dallo schema corrente.\r\n   * Estratto per poter essere richiamato sia da ngOnInit che da ngOnChanges.\r\n   */\r\n  private initFormFromSchema(): void {\r\n    if (!this.schema) {\r\n      this.logger?.logFormAction('init', { schemaId: 'unknown', error: 'schema nullo' });\r\n      return;\r\n    }\r\n    const totalFields = this.schema.sections?.reduce((sum, s) => sum + s.fields.length, 0) ?? 0;\r\n    this.logger?.logFormAction('init', {\r\n      schemaId: this.schema.id,\r\n      sectionCount: this.schema.sections?.length,\r\n      fieldCount: totalFields,\r\n    });\r\n    this.currentSchemaId = this.schema.id;\r\n    this.buildSectionAccordionMap();\r\n    this.buildForm();\r\n    // Dopo il FormArray reale, allinea i descriptor accordion (max tra min e righe initialData).\r\n    for (const section of this.repeatableSections) {\r\n      this.rebuildRepeatableAccordion(section);\r\n    }\r\n    this.isInitializing = false;\r\n    this.logger?.debug('form', 'formBuilt', {\r\n      schemaId: this.schema.id,\r\n      controlKeys: Object.keys(this.formGroup.controls),\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Pulisce lo stato del form prima di un rebuild.\r\n   */\r\n  private destroyForm(): void {\r\n    this.logger?.debug('form', 'destroyForm', { schemaId: this.currentSchemaId });\r\n    this.valueChangeSub?.unsubscribe();\r\n    this.valueChangeSub = undefined;\r\n    this.filteredOptions = {};\r\n    this.prevalorizedFields.clear();\r\n    this.validationRulesMap = {};\r\n    this.fieldDependencies.clear();\r\n    this.sectionAccordionMap.clear();\r\n    this.isInitializing = true;\r\n    this.currentSchemaId = null;\r\n  }\r\n\r\n  // ─── Costruzione form ───────────────────────────────────────────\r\n\r\n  private buildForm(): void {\r\n    const controls: Record<string, AbstractControl> = {};\r\n\r\n    // Campi piatti (sezioni non-repeatable)\r\n    for (const field of this.allFlatFields) {\r\n      const initialValue = this.initialData?.[field.key] ?? field.defaultValue ?? null;\r\n      const isDisabled = field.disabled || this.disabled;\r\n\r\n      const control = new FormControl({ value: initialValue, disabled: isDisabled });\r\n\r\n      if (field.validation?.length) {\r\n        this.validationRulesMap[field.key] = field.validation;\r\n      }\r\n\r\n      if (initialValue != null && initialValue !== '' && initialValue !== false) {\r\n        this.prevalorizedFields.add(field.key);\r\n      }\r\n\r\n      if (field.options && !this.isObservable(field.options)) {\r\n        this.filteredOptions[field.key] = [...(field.options as UiFieldOption[])];\r\n      }\r\n\r\n      controls[field.key] = control;\r\n    }\r\n\r\n    // FormArray per sezioni repeatable\r\n    for (const section of this.repeatableSections) {\r\n      const initialArray = this.initialData?.[section.id] as Record<string, any>[] | undefined;\r\n      const count = this.getRepeatableInitialInstanceCount(section);\r\n\r\n      const groups: FormGroup[] = [];\r\n      for (let i = 0; i < count; i++) {\r\n        groups.push(this.buildInstanceFormGroup(section, initialArray?.[i]));\r\n      }\r\n      controls[section.id] = new FormArray(groups);\r\n    }\r\n\r\n    this.formGroup = new FormGroup(controls);\r\n\r\n    // Applica validatori iniziali\r\n    this.applyAllValidators();\r\n\r\n    // Registra dipendenze\r\n    this.buildDependencyMap();\r\n\r\n    // Sottoscrivi ai cambiamenti di valore\r\n    this.valueChangeSub = this.formGroup.valueChanges.pipe(debounceTime(50), takeUntil(this.destroy$)).subscribe(() => {\r\n      this.evaluateAllConditions();\r\n      this.updateDependentOptions();\r\n      if (!this.isInitializing) {\r\n        this.valueChange.emit(this.getFormValue());\r\n        this.validationChange.emit(this.getValidationState());\r\n        this.cdr.markForCheck();\r\n      }\r\n    });\r\n\r\n    // Valutazione condizioni iniziale\r\n    this.evaluateAllConditions();\r\n\r\n    // BlackBox: setup form event tracking\r\n    this.setupBlackboxTracking();\r\n  }\r\n\r\n  /** Costruisce un FormGroup per una singola istanza di sezione repeatable. */\r\n  private buildInstanceFormGroup(section: UiFormSection, data?: Record<string, any>): FormGroup {\r\n    const controls: Record<string, FormControl> = {};\r\n\r\n    for (const field of section.fields) {\r\n      const initialValue = data?.[field.key] ?? field.defaultValue ?? null;\r\n      const isDisabled = field.disabled || this.disabled;\r\n      controls[field.key] = new FormControl({ value: initialValue, disabled: isDisabled });\r\n\r\n      if (field.options && !this.isObservable(field.options)) {\r\n        this.filteredOptions[field.key] = [...(field.options as UiFieldOption[])];\r\n      }\r\n    }\r\n\r\n    const fg = new FormGroup(controls);\r\n\r\n    // Applica validatori all'istanza\r\n    for (const field of section.fields) {\r\n      if (field.validation?.length) {\r\n        const formData = fg.getRawValue();\r\n        this.validationService.updateFieldValidators(fg.get(field.key)!, field.validation, formData);\r\n      }\r\n    }\r\n\r\n    return fg;\r\n  }\r\n\r\n  // ─── BlackBox form tracking ──────────────────────────────────────\r\n\r\n  /**\r\n   * Sets up BlackBox form event tracking.\r\n   * - Focus/blur: DOM event delegation on the host element\r\n   * - Value changes: per-field subscriptions with debounce\r\n   * - Validation errors: per-field statusChanges subscriptions\r\n   * @internal\r\n   */\r\n  private setupBlackboxTracking(): void {\r\n    if (!this.blackbox) return;\r\n    const config = this.blackbox.getConfig().formTracking;\r\n    const currentRoute = this.bbRouter?.url ?? '';\r\n    const formId = this.schema?.id ?? 'unknown';\r\n\r\n    // Focus tracking via event delegation\r\n    if (config.trackFocus) {\r\n      this.bbFocusHandler = (e: FocusEvent) => {\r\n        const fieldKey = this.resolveFieldKeyFromEvent(e);\r\n        if (!fieldKey) return;\r\n        this.blackbox!.trackFormEvent({\r\n          timestamp: Date.now(),\r\n          route: this.bbRouter?.url ?? currentRoute,\r\n          formId,\r\n          fieldKey,\r\n          eventType: 'focus',\r\n        });\r\n      };\r\n      this.elRef.nativeElement.addEventListener('focusin', this.bbFocusHandler, true);\r\n    }\r\n\r\n    // Blur tracking via event delegation\r\n    if (config.trackBlur) {\r\n      this.bbBlurHandler = (e: FocusEvent) => {\r\n        const fieldKey = this.resolveFieldKeyFromEvent(e);\r\n        if (!fieldKey) return;\r\n        this.blackbox!.trackFormEvent({\r\n          timestamp: Date.now(),\r\n          route: this.bbRouter?.url ?? currentRoute,\r\n          formId,\r\n          fieldKey,\r\n          eventType: 'blur',\r\n        });\r\n      };\r\n      this.elRef.nativeElement.addEventListener('focusout', this.bbBlurHandler, true);\r\n    }\r\n\r\n    // Per-field value change + validation tracking\r\n    for (const field of this.allFields) {\r\n      const control = this.formGroup.get(field.key);\r\n      if (!control) continue;\r\n\r\n      // Value changes\r\n      if (config.trackValueChanges) {\r\n        control.valueChanges\r\n          .pipe(\r\n            debounceTime(config.debounceMs),\r\n            distinctUntilChanged(),\r\n            takeUntil(this.destroy$),\r\n          )\r\n          .subscribe((value) => {\r\n            this.blackbox!.trackFormEvent({\r\n              timestamp: Date.now(),\r\n              route: this.bbRouter?.url ?? currentRoute,\r\n              formId,\r\n              fieldKey: field.key,\r\n              eventType: 'valueChange',\r\n              metadata: {\r\n                value: config.trackValues ? value : undefined,\r\n                valid: control.valid,\r\n                formValues: config.trackValues ? this.formGroup.getRawValue() : undefined,\r\n              },\r\n            });\r\n          });\r\n      }\r\n\r\n      // Validation errors\r\n      if (config.trackValidation) {\r\n        control.statusChanges\r\n          .pipe(\r\n            rxFilter((status) => status === 'INVALID'),\r\n            distinctUntilChanged(),\r\n            takeUntil(this.destroy$),\r\n          )\r\n          .subscribe(() => {\r\n            const errors = control.errors\r\n              ? Object.keys(control.errors)\r\n              : [];\r\n            this.blackbox!.trackFormEvent({\r\n              timestamp: Date.now(),\r\n              route: this.bbRouter?.url ?? currentRoute,\r\n              formId,\r\n              fieldKey: field.key,\r\n              eventType: 'validationError',\r\n              metadata: {\r\n                valid: false,\r\n                errors,\r\n              },\r\n            });\r\n          });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resolve the form field key from a focus/blur DOM event.\r\n   * Walks up from the event target looking for `formControlName` or `data-field-key`.\r\n   * @internal\r\n   */\r\n  private resolveFieldKeyFromEvent(e: FocusEvent): string | null {\r\n    let target = e.target as HTMLElement | null;\r\n    const maxDepth = 5;\r\n    let depth = 0;\r\n\r\n    while (target && depth < maxDepth) {\r\n      // formControlName attribute\r\n      const fcn = target.getAttribute('formControlName');\r\n      if (fcn) return fcn;\r\n\r\n      // data-field-key attribute\r\n      const dfk = target.getAttribute('data-field-key');\r\n      if (dfk) return dfk;\r\n\r\n      target = target.parentElement;\r\n      depth++;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  // ─── Validazione ────────────────────────────────────────────────\r\n\r\n  private applyAllValidators(): void {\r\n    // Campi piatti\r\n    for (const field of this.allFlatFields) {\r\n      if (field.validation?.length) {\r\n        const formData = this.formGroup.getRawValue();\r\n        this.validationService.updateFieldValidators(this.formGroup.get(field.key)!, field.validation, formData);\r\n      }\r\n    }\r\n\r\n    // Campi nelle istanze repeatable\r\n    for (const section of this.repeatableSections) {\r\n      const arr = this.getRepeatableArray(section.id);\r\n      if (!arr) continue;\r\n      for (let i = 0; i < arr.length; i++) {\r\n        const instanceFg = arr.at(i) as FormGroup;\r\n        for (const field of section.fields) {\r\n          if (field.validation?.length) {\r\n            const formData = instanceFg.getRawValue();\r\n            this.validationService.updateFieldValidators(instanceFg.get(field.key)!, field.validation, formData);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // ─── Condizioni ─────────────────────────────────────────────────\r\n\r\n  private evaluateAllConditions(): void {\r\n    const formData = this.formGroup.getRawValue();\r\n\r\n    // Campi piatti\r\n    for (const field of this.allFlatFields) {\r\n      this.evaluateFieldConditions(field, this.formGroup, formData);\r\n    }\r\n\r\n    // Campi nelle istanze repeatable (scope intra-istanza)\r\n    for (const section of this.repeatableSections) {\r\n      const arr = this.getRepeatableArray(section.id);\r\n      if (!arr) continue;\r\n      for (let i = 0; i < arr.length; i++) {\r\n        const instanceFg = arr.at(i) as FormGroup;\r\n        const instanceData = instanceFg.getRawValue();\r\n        for (const field of section.fields) {\r\n          this.evaluateFieldConditions(field, instanceFg, instanceData);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Valuta condizioni di visibilita/disabilitazione per un singolo campo nel contesto del FormGroup dato. */\r\n  private evaluateFieldConditions(field: UiFormFieldDescriptor, fg: FormGroup, formData: Record<string, any>): void {\r\n    if (field.conditions?.length) {\r\n      const visible = this.conditionService.evaluateConditions(field.conditions, formData);\r\n      const control = fg.get(field.key);\r\n      if (control) {\r\n        if (!visible && control.enabled) {\r\n          control.disable({ emitEvent: false });\r\n          if (!field.freezeValueOnDisable) {\r\n            control.setValue(field.defaultValue ?? null, { emitEvent: false });\r\n          }\r\n        } else if (visible && control.disabled && !field.disabled && !this.disabled) {\r\n          control.enable({ emitEvent: false });\r\n        }\r\n      }\r\n    }\r\n\r\n    if (field.disableConditions?.length && !field.conditions?.length) {\r\n      const shouldDisable = this.conditionService.evaluateConditions(field.disableConditions, formData);\r\n      const control = fg.get(field.key);\r\n      if (control) {\r\n        if (shouldDisable && control.enabled) {\r\n          control.disable({ emitEvent: false });\r\n          if (!field.freezeValueOnDisable) {\r\n            control.setValue(field.defaultValue ?? null, { emitEvent: false });\r\n          }\r\n        } else if (!shouldDisable && control.disabled && !field.disabled && !this.disabled) {\r\n          control.enable({ emitEvent: false });\r\n        }\r\n      }\r\n    }\r\n\r\n    if (field.validation?.some((r) => r.conditions?.length)) {\r\n      this.validationService.updateFieldValidators(fg.get(field.key)!, field.validation!, formData);\r\n    }\r\n  }\r\n\r\n  // ─── Dipendenze opzioni ─────────────────────────────────────────\r\n\r\n  private buildDependencyMap(): void {\r\n    for (const field of this.allFields) {\r\n      if (field.dependentOptions?.dependsOn) {\r\n        const depKey = field.dependentOptions.dependsOn;\r\n        if (!this.fieldDependencies.has(depKey)) {\r\n          this.fieldDependencies.set(depKey, new Set());\r\n        }\r\n        this.fieldDependencies.get(depKey)!.add(field.key);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Costruisce la mappa dei descriptors accordion per le sezioni collapsibili.\r\n   * Ogni sezione collapsibile viene mappata a un singolo UiAccordionDescriptor.\r\n   * @internal\r\n   */\r\n  private buildSectionAccordionMap(): void {\r\n    this.sectionAccordionMap.clear();\r\n    this.repeatableAccordionMap.clear();\r\n\r\n    for (const section of this.schema.sections) {\r\n      if (section.repeatable) {\r\n        this.rebuildRepeatableAccordion(section);\r\n      } else if (section.collapsible) {\r\n        this.sectionAccordionMap.set(section.id, [{\r\n          id: section.id,\r\n          title: section.title || '',\r\n          icon: section.icon,\r\n          expanded: !section.collapsed,\r\n          subtitle: section.description,\r\n        }]);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Numero di istanze repeatable da creare al build/reset:\r\n   * almeno `repeatable.min` (se `min > 0` o omesso default 1), mai meno delle righe in `initialData[section.id]`.\r\n   * Con `min: 0` non si aggiungono righe oltre a quelle già presenti nei dati iniziali.\r\n   */\r\n  private getRepeatableInitialInstanceCount(section: UiFormSection): number {\r\n    const cfg = section.repeatable;\r\n    if (!cfg) return 0;\r\n    const initialArray = this.initialData?.[section.id] as Record<string, any>[] | undefined;\r\n    const initialLen = initialArray?.length ?? 0;\r\n    const minReq = cfg.min;\r\n    if (minReq === 0) {\r\n      return initialLen;\r\n    }\r\n    const minInstances = minReq ?? 1;\r\n    return Math.max(initialLen, minInstances);\r\n  }\r\n\r\n  /** Ricostruisce i descriptor accordion per le istanze di una sezione repeatable. */\r\n  private rebuildRepeatableAccordion(section: UiFormSection): void {\r\n    const arr = this.getRepeatableArray(section.id);\r\n    const count = arr?.length ?? this.getRepeatableInitialInstanceCount(section);\r\n    const titleTemplate = section.repeatable!.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');\r\n    const items: UiAccordionDescriptor[] = [];\r\n\r\n    for (let i = 0; i < count; i++) {\r\n      items.push({\r\n        id: `${section.id}-${i}`,\r\n        title: titleTemplate.replace('{index}', String(i + 1)),\r\n        icon: section.icon,\r\n        expanded: true,\r\n        index: i,\r\n      });\r\n    }\r\n\r\n    this.repeatableAccordionMap.set(section.id, items);\r\n  }\r\n\r\n  private updateDependentOptions(): void {\r\n    const formData = this.formGroup.getRawValue();\r\n\r\n    for (const field of this.allFields) {\r\n      // Dynamic options\r\n      if (field.dynamicOptions) {\r\n        if (field.dynamicOptions.type === 'year-range') {\r\n          const min = field.dynamicOptions.minYear || new Date().getFullYear() - 10;\r\n          const max = field.dynamicOptions.maxYear || new Date().getFullYear();\r\n          const opts: UiFieldOption[] = [];\r\n          for (let y = max; y >= min; y--) {\r\n            opts.push({ value: y, label: String(y) });\r\n          }\r\n          this.filteredOptions[field.key] = opts;\r\n        } else if (field.dynamicOptions.generator) {\r\n          this.filteredOptions[field.key] = field.dynamicOptions.generator(formData);\r\n        }\r\n      }\r\n\r\n      // Dependent options\r\n      if (field.dependentOptions && field.options && !this.isObservable(field.options)) {\r\n        const dep = field.dependentOptions;\r\n        const depValue = formData[dep.dependsOn];\r\n        const allOptions = field.options as UiFieldOption[];\r\n\r\n        if (depValue == null || depValue === '') {\r\n          this.filteredOptions[field.key] = [...allOptions];\r\n          continue;\r\n        }\r\n\r\n        this.filteredOptions[field.key] = allOptions.filter((opt) => {\r\n          if (dep.filterType === 'custom' && dep.filterFn) {\r\n            return dep.filterFn(opt, depValue, formData);\r\n          }\r\n          const optVal = Number(opt.value);\r\n          const depVal = Number(depValue);\r\n          if (isNaN(optVal) || isNaN(depVal)) return true;\r\n\r\n          switch (dep.filterType) {\r\n            case 'greater_than':\r\n              return optVal > depVal;\r\n            case 'greater_equal':\r\n              return optVal >= depVal;\r\n            case 'less_than':\r\n              return optVal < depVal;\r\n            case 'less_equal':\r\n              return optVal <= depVal;\r\n            case 'equals':\r\n              return optVal === depVal;\r\n            case 'not_equals':\r\n              return optVal !== depVal;\r\n            default:\r\n              return true;\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  // ─── API pubblica ───────────────────────────────────────────────\r\n\r\n  /** Verifica se un campo e visibile (opzionalmente nel contesto di un FormGroup specifico). */\r\n  isFieldVisible(fieldKey: string, fg?: FormGroup): boolean {\r\n    const field = this.allFields.find((f) => f.key === fieldKey);\r\n    if (!field?.conditions?.length) return true;\r\n    const target = fg || this.formGroup;\r\n    return this.conditionService.evaluateConditions(field.conditions, target.getRawValue());\r\n  }\r\n\r\n  /** Verifica se un campo e obbligatorio (include validazione condizionale). */\r\n  isFieldRequired(fieldKey: string, fg?: FormGroup): boolean {\r\n    const field = this.allFields.find((f) => f.key === fieldKey);\r\n    if (field?.required) return true;\r\n\r\n    const rules = field?.validation || [];\r\n    const target = fg || this.formGroup;\r\n    const formData = target.getRawValue();\r\n    return rules.some((r) => {\r\n      if (r.type !== 'required') return false;\r\n      if (!r.conditions?.length) return true;\r\n      return this.conditionService.evaluateConditions(r.conditions, formData);\r\n    });\r\n  }\r\n\r\n  /** Verifica se una sezione e visibile. */\r\n  isSectionVisible(sectionId: string): boolean {\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section?.conditions?.length) return true;\r\n    return this.conditionService.evaluateConditions(section.conditions, this.formGroup.getRawValue());\r\n  }\r\n\r\n  /** Descriptors accordion per una sezione collapsibile. */\r\n  getSectionAccordionItems(sectionId: string): UiAccordionDescriptor[] {\r\n    return this.sectionAccordionMap.get(sectionId) || [];\r\n  }\r\n\r\n  /** Descriptors accordion per le istanze di una sezione repeatable. */\r\n  getRepeatableAccordionItems(sectionId: string): UiAccordionDescriptor[] {\r\n    return this.repeatableAccordionMap.get(sectionId) || [];\r\n  }\r\n\r\n  /** Verifica se mostrare errori per un campo. */\r\n  shouldShowFieldErrors(fieldKey: string, fg?: FormGroup): boolean {\r\n    const target = fg || this.formGroup;\r\n    const control = target.get(fieldKey);\r\n    return this.fieldErrorService.shouldShowFieldErrors(control, {\r\n      treatAsPrevalorized: this.prevalorizedFields.has(fieldKey),\r\n    });\r\n  }\r\n\r\n  /** Errori di un campo come array di messaggi. */\r\n  getFieldErrors(fieldKey: string, fg?: FormGroup): string[] {\r\n    const target = fg || this.formGroup;\r\n    const control = target.get(fieldKey);\r\n    const field = this.allFields.find((f) => f.key === fieldKey);\r\n    return this.fieldErrorService.getFieldErrors(control, field?.validation);\r\n  }\r\n\r\n  /** Valore completo del form (include campi disabilitati). */\r\n  getFormValue(): UiFormData {\r\n    return this.formGroup.getRawValue();\r\n  }\r\n\r\n  /** Il form e valido. */\r\n  isFormValid(): boolean {\r\n    return this.formGroup.valid;\r\n  }\r\n\r\n  /**\r\n   * True se tutti i controlli sono validi, ignorando le chiavi indicate\r\n   * (flat e dentro ogni istanza repeatable).\r\n   */\r\n  isFormValidExcludingFieldKeys(excludedKeys: ReadonlySet<string>): boolean {\r\n    return this.isFormGroupValidExcluding(this.formGroup, excludedKeys);\r\n  }\r\n\r\n  /**\r\n   * Risolve la chiave per `customFieldTemplates` (`templateKey` → `component` → `field.key`).\r\n   */\r\n  resolveCustomTemplateKey(field: UiFormFieldDescriptor): string {\r\n    const cc = field.customConfig;\r\n    return cc?.templateKey ?? cc?.component ?? field.key;\r\n  }\r\n\r\n  /**\r\n   * Template Angular registrato per il campo custom, o fallback globale.\r\n   */\r\n  getCustomTemplateRef(field: UiFormFieldDescriptor): TemplateRef<unknown> | null {\r\n    const key = this.resolveCustomTemplateKey(field);\r\n    return this.customFieldTemplates[key] ?? this.customFieldTemplateFallback ?? null;\r\n  }\r\n\r\n  /**\r\n   * Contesto passato a `ngTemplateOutlet` per il campo custom (CVA sul `control`).\r\n   */\r\n  getCustomFieldOutletContext(\r\n    field: UiFormFieldDescriptor,\r\n    fg: FormGroup,\r\n    nestedErrorKeyPrefix?: string,\r\n  ): UiCustomFieldTemplateContext {\r\n    const control = fg.get(field.key) as FormControl;\r\n    return {\r\n      $implicit: field,\r\n      field,\r\n      formGroup: fg,\r\n      control,\r\n      config: field.customConfig?.config ?? {},\r\n      nestedErrorKeyPrefix,\r\n      emitCustomEvent: (event: string, data?: unknown) => {\r\n        this.customEvent.emit({ field: field.key, event, data });\r\n      },\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Template e contesto in un solo oggetto (evita doppie valutazioni nel template).\r\n   */\r\n  getCustomFieldOutlet(\r\n    field: UiFormFieldDescriptor,\r\n    fg: FormGroup,\r\n    nestedErrorKeyPrefix?: string,\r\n  ): { template: TemplateRef<unknown>; context: UiCustomFieldTemplateContext } | null {\r\n    const template = this.getCustomTemplateRef(field);\r\n    if (!template) return null;\r\n    return { template, context: this.getCustomFieldOutletContext(field, fg, nestedErrorKeyPrefix) };\r\n  }\r\n\r\n  /** Prefisso chiavi errore per campi custom annidati (flat o repeatable). */\r\n  buildNestedErrorKeyPrefix(fieldKey: string, instanceKeyPrefix?: string): string {\r\n    const base = instanceKeyPrefix ? `${instanceKeyPrefix}${fieldKey}` : fieldKey;\r\n    return `${base}__`;\r\n  }\r\n\r\n  /** Merge errori nested da CVA custom nel dettaglio error-summary. */\r\n  private appendCustomNestedFieldErrors(\r\n    details: UiFormErrorDetail[],\r\n    field: UiFormFieldDescriptor,\r\n    control: AbstractControl,\r\n    labelPrefix: string,\r\n    nestedErrorKeyPrefix: string,\r\n  ): void {\r\n    if (field.type !== 'custom') return;\r\n    const nested = control.errors?.[UI_FORM_NESTED_FIELD_ERRORS_KEY];\r\n    if (!Array.isArray(nested) || nested.length === 0) return;\r\n\r\n    for (const item of nested as UiFormErrorDetail[]) {\r\n      if (!item?.errors?.length) continue;\r\n      const relativeKey = item.fieldKey ?? '';\r\n      details.push({\r\n        fieldKey: relativeKey ? `${nestedErrorKeyPrefix}${relativeKey}` : nestedErrorKeyPrefix.slice(0, -2),\r\n        fieldLabel: `${labelPrefix} > ${item.fieldLabel}`,\r\n        errors: item.errors,\r\n      });\r\n    }\r\n  }\r\n\r\n  private isFormGroupValidExcluding(group: FormGroup, excludedKeys: ReadonlySet<string>): boolean {\r\n    for (const key of Object.keys(group.controls)) {\r\n      const c = group.get(key);\r\n      if (!c) continue;\r\n      if (c instanceof FormArray) {\r\n        for (let i = 0; i < c.length; i++) {\r\n          const row = c.at(i);\r\n          if (row instanceof FormGroup && !this.isFormGroupValidExcluding(row, excludedKeys)) {\r\n            return false;\r\n          }\r\n        }\r\n      } else if (c instanceof FormGroup) {\r\n        if (!this.isFormGroupValidExcluding(c, excludedKeys)) return false;\r\n      } else if (c instanceof FormControl) {\r\n        if (excludedKeys.has(key)) continue;\r\n        if (c.invalid) return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /** Stato di validazione completo. */\r\n  getValidationState(): UiFormValidationState {\r\n    const errors: Record<string, string[]> = {};\r\n    const dirty: string[] = [];\r\n    const touched: string[] = [];\r\n\r\n    for (const field of this.allFlatFields) {\r\n      const control = this.formGroup.get(field.key);\r\n      if (!control) continue;\r\n      if (control.dirty) dirty.push(field.key);\r\n      if (control.touched) touched.push(field.key);\r\n      const fieldErrors = this.getFieldErrors(field.key);\r\n      if (fieldErrors.length) errors[field.key] = fieldErrors;\r\n    }\r\n\r\n    // Includi errori delle istanze repeatable\r\n    for (const section of this.repeatableSections) {\r\n      const arr = this.getRepeatableArray(section.id);\r\n      if (!arr) continue;\r\n      for (let i = 0; i < arr.length; i++) {\r\n        const instanceFg = arr.at(i) as FormGroup;\r\n        for (const field of section.fields) {\r\n          const control = instanceFg.get(field.key);\r\n          if (!control) continue;\r\n          const prefixedKey = `${section.id}[${i}].${field.key}`;\r\n          if (control.dirty) dirty.push(prefixedKey);\r\n          if (control.touched) touched.push(prefixedKey);\r\n          const fieldErrors = this.getFieldErrors(field.key, instanceFg);\r\n          if (fieldErrors.length) errors[prefixedKey] = fieldErrors;\r\n        }\r\n      }\r\n    }\r\n\r\n    return { valid: this.formGroup.valid, errors, dirty, touched };\r\n  }\r\n\r\n  /** Errori dettagliati per l'error summary. */\r\n  getDetailedFormErrors(): UiFormErrorDetail[] {\r\n    const details: UiFormErrorDetail[] = [];\r\n\r\n    // Campi piatti\r\n    for (const field of this.allFlatFields) {\r\n      if (field.type === 'flag' || field.type === 'divider') continue;\r\n      if (!this.isFieldVisible(field.key)) continue;\r\n      const control = this.formGroup.get(field.key);\r\n      if (!control?.errors) continue;\r\n\r\n      const nestedPrefix = this.buildNestedErrorKeyPrefix(field.key);\r\n      this.appendCustomNestedFieldErrors(details, field, control, field.label, nestedPrefix);\r\n\r\n      if (field.type === 'custom' && control.errors[UI_FORM_NESTED_FIELD_ERRORS_KEY]) {\r\n        continue;\r\n      }\r\n\r\n      const errors = this.getFieldErrors(field.key);\r\n      if (errors.length) {\r\n        details.push({ fieldKey: field.key, fieldLabel: field.label, errors });\r\n      }\r\n    }\r\n\r\n    // Campi nelle istanze repeatable\r\n    for (const section of this.repeatableSections) {\r\n      const arr = this.getRepeatableArray(section.id);\r\n      if (!arr) continue;\r\n      const titleTemplate = section.repeatable!.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');\r\n      for (let i = 0; i < arr.length; i++) {\r\n        const instanceFg = arr.at(i) as FormGroup;\r\n        const instanceLabel = titleTemplate.replace('{index}', String(i + 1));\r\n        const instanceKeyPrefix = `${section.id}[${i}].`;\r\n        for (const field of section.fields) {\r\n          if (field.type === 'flag' || field.type === 'divider') continue;\r\n          if (!this.isFieldVisible(field.key, instanceFg)) continue;\r\n          const control = instanceFg.get(field.key);\r\n          if (!control?.errors) continue;\r\n\r\n          const nestedPrefix = this.buildNestedErrorKeyPrefix(field.key, instanceKeyPrefix);\r\n          this.appendCustomNestedFieldErrors(\r\n            details,\r\n            field,\r\n            control,\r\n            `${instanceLabel} > ${field.label}`,\r\n            nestedPrefix,\r\n          );\r\n\r\n          if (field.type === 'custom' && control.errors[UI_FORM_NESTED_FIELD_ERRORS_KEY]) {\r\n            continue;\r\n          }\r\n\r\n          const errors = this.getFieldErrors(field.key, instanceFg);\r\n          if (errors.length) {\r\n            details.push({\r\n              fieldKey: `${section.id}[${i}].${field.key}`,\r\n              fieldLabel: `${instanceLabel} > ${field.label}`,\r\n              errors,\r\n            });\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return details;\r\n  }\r\n\r\n  /** Conta errori totali. */\r\n  getFormErrorsCount(): number {\r\n    return this.getDetailedFormErrors().reduce((sum, d) => sum + d.errors.length, 0);\r\n  }\r\n\r\n  /** Controlla se ci sono errori. */\r\n  hasFormErrors(): boolean {\r\n    return this.getFormErrorsCount() > 0;\r\n  }\r\n\r\n  /** Controllo per un campo. */\r\n  getFieldControl(key: string): FormControl | null {\r\n    return (this.formGroup.get(key) as FormControl) ?? null;\r\n  }\r\n\r\n  /** Aggiorna il valore di un campo programmaticamente. */\r\n  updateFieldValue(key: string, value: any): void {\r\n    const control = this.formGroup.get(key);\r\n    if (control) {\r\n      control.setValue(value);\r\n      control.markAsDirty();\r\n    }\r\n  }\r\n\r\n  /** Forza la validazione di tutti i campi (incluse istanze repeatable). */\r\n  validateAllFields(): void {\r\n    // Campi piatti\r\n    Object.keys(this.formGroup.controls).forEach((key) => {\r\n      const control = this.formGroup.get(key);\r\n      if (control instanceof FormArray) {\r\n        for (let i = 0; i < control.length; i++) {\r\n          const fg = control.at(i) as FormGroup;\r\n          Object.keys(fg.controls).forEach((fk) => {\r\n            const c = fg.get(fk);\r\n            c?.markAsTouched();\r\n            c?.markAsDirty();\r\n            c?.updateValueAndValidity();\r\n          });\r\n        }\r\n      } else {\r\n        control?.markAsTouched();\r\n        control?.markAsDirty();\r\n        control?.updateValueAndValidity();\r\n      }\r\n    });\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  // ─── API Repeatable ────────────────────────────────────────────\r\n\r\n  /** Restituisce il FormArray di una sezione repeatable. */\r\n  getRepeatableArray(sectionId: string): FormArray | null {\r\n    const control = this.formGroup?.get(sectionId);\r\n    return control instanceof FormArray ? control : null;\r\n  }\r\n\r\n  /** Restituisce il FormGroup di una specifica istanza repeatable. */\r\n  getInstanceFormGroup(sectionId: string, index: number): FormGroup | null {\r\n    const arr = this.getRepeatableArray(sectionId);\r\n    return arr?.at(index) as FormGroup ?? null;\r\n  }\r\n\r\n  /** Verifica se e possibile aggiungere nuove istanze. */\r\n  canAddInstance(sectionId: string): boolean {\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section?.repeatable) return false;\r\n    const arr = this.getRepeatableArray(sectionId);\r\n    if (!arr) return false;\r\n    return section.repeatable.max == null || arr.length < section.repeatable.max;\r\n  }\r\n\r\n  /** Verifica se e possibile rimuovere istanze. */\r\n  canRemoveInstance(sectionId: string): boolean {\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section?.repeatable) return false;\r\n    const arr = this.getRepeatableArray(sectionId);\r\n    if (!arr) return false;\r\n    return arr.length > (section.repeatable.min ?? 1);\r\n  }\r\n\r\n  /** Aggiunge una nuova istanza vuota a una sezione repeatable. */\r\n  addRepeatableInstance(sectionId: string): void {\r\n    if (!this.canAddInstance(sectionId)) return;\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section) return;\r\n\r\n    const arr = this.getRepeatableArray(sectionId)!;\r\n    arr.push(this.buildInstanceFormGroup(section));\r\n    this.rebuildRepeatableAccordion(section);\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  /** Rimuove un'istanza da una sezione repeatable. */\r\n  removeRepeatableInstance(sectionId: string, index: number): void {\r\n    if (!this.canRemoveInstance(sectionId)) return;\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section?.repeatable) return;\r\n\r\n    if (section.repeatable.confirmRemove) {\r\n      const msg = section.repeatable.confirmMessage ?? 'Sei sicuro di voler rimuovere questa sezione?';\r\n      if (!confirm(msg)) return;\r\n    }\r\n\r\n    const arr = this.getRepeatableArray(sectionId)!;\r\n    arr.removeAt(index);\r\n    this.rebuildRepeatableAccordion(section);\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  /** Duplica un'istanza esistente con i suoi valori. */\r\n  duplicateRepeatableInstance(sectionId: string, index: number): void {\r\n    if (!this.canAddInstance(sectionId)) return;\r\n    const section = this.schema.sections.find((s) => s.id === sectionId);\r\n    if (!section) return;\r\n\r\n    const arr = this.getRepeatableArray(sectionId)!;\r\n    const sourceData = (arr.at(index) as FormGroup).getRawValue();\r\n    const newGroup = this.buildInstanceFormGroup(section, sourceData);\r\n    arr.insert(index + 1, newGroup);\r\n    this.rebuildRepeatableAccordion(section);\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  /** Titolo di un'istanza repeatable. */\r\n  getInstanceTitle(section: UiFormSection, index: number): string {\r\n    const template = section.repeatable?.instanceTitle || (section.title ? `${section.title} {index}` : 'Elemento {index}');\r\n    return template.replace('{index}', String(index + 1));\r\n  }\r\n\r\n  /** Scrolla al campo e lo evidenzia. */\r\n  scrollToField(fieldKey: string): void {\r\n    const control = this.formGroup.get(fieldKey);\r\n    if (control) {\r\n      control.markAsTouched();\r\n      control.markAsDirty();\r\n      control.updateValueAndValidity();\r\n    }\r\n\r\n    setTimeout(() => {\r\n      const selectors = [`[data-field-key=\"${fieldKey}\"]`, `[formControlName=\"${fieldKey}\"]`];\r\n      let targetElement: HTMLElement | null = null;\r\n      for (const sel of selectors) {\r\n        targetElement = this.elRef.nativeElement.querySelector(sel);\r\n        if (targetElement) break;\r\n      }\r\n      if (!targetElement) return;\r\n\r\n      // Se trovato il formControlName, risali al wrapper\r\n      if (targetElement.hasAttribute('formControlName')) {\r\n        const wrapper = targetElement.closest('.ui-form-builder__field-wrapper, mat-form-field');\r\n        if (wrapper) targetElement = wrapper as HTMLElement;\r\n      }\r\n\r\n      targetElement.scrollIntoView({ behavior: 'smooth', block: 'center' });\r\n\r\n      // Aggiungi classe highlight e rimuovila dopo l'animazione\r\n      targetElement.classList.add('ui-form-field--highlight');\r\n      setTimeout(() => targetElement!.classList.remove('ui-form-field--highlight'), 2000);\r\n    }, 100);\r\n  }\r\n\r\n  /** Submit del form. */\r\n  onSubmit(): void {\r\n    this.validateAllFields();\r\n    const formValue = this.getFormValue();\r\n    const isValid = this.formGroup.valid;\r\n    this.logger?.logFormAction('submit', {\r\n      schemaId: this.schema?.id ?? 'unknown',\r\n      valid: isValid,\r\n      fieldCount: Object.keys(formValue).length,\r\n    });\r\n    if (isValid) {\r\n      this.formSubmit.emit(formValue);\r\n    }\r\n  }\r\n\r\n  /** Reset del form. */\r\n  onReset(): void {\r\n    // Resetta campi piatti\r\n    for (const field of this.allFlatFields) {\r\n      const value = this.initialData?.[field.key] ?? field.defaultValue ?? null;\r\n      const control = this.formGroup.get(field.key);\r\n      control?.setValue(value, { emitEvent: false });\r\n      control?.markAsPristine();\r\n      control?.markAsUntouched();\r\n    }\r\n\r\n    // Resetta sezioni repeatable\r\n    for (const section of this.repeatableSections) {\r\n      const arr = this.getRepeatableArray(section.id);\r\n      if (!arr) continue;\r\n      const initialArray = this.initialData?.[section.id] as Record<string, any>[] | undefined;\r\n      const count = this.getRepeatableInitialInstanceCount(section);\r\n\r\n      arr.clear();\r\n      for (let i = 0; i < count; i++) {\r\n        arr.push(this.buildInstanceFormGroup(section, initialArray?.[i]));\r\n      }\r\n      this.rebuildRepeatableAccordion(section);\r\n    }\r\n\r\n    this.formGroup.updateValueAndValidity();\r\n    this.formReset.emit();\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  // ─── Template helpers ───────────────────────────────────────────\r\n\r\n  /** Opzioni per un campo (filtrando per autocomplete query). */\r\n  getFieldOptions(field: UiFormFieldDescriptor): UiFieldOption[] {\r\n    return this.filteredOptions[field.key] || [];\r\n  }\r\n\r\n  /** Filtra opzioni per autocomplete. */\r\n  filterOptions(field: UiFormFieldDescriptor, query: string): void {\r\n    if (!query) {\r\n      if (field.options && !this.isObservable(field.options)) {\r\n        this.filteredOptions[field.key] = [...(field.options as UiFieldOption[])];\r\n      }\r\n      return;\r\n    }\r\n\r\n    const lowerQuery = query.toLowerCase();\r\n\r\n    if (field.asyncOptions) {\r\n      field.asyncOptions(query).then((opts) => {\r\n        this.filteredOptions[field.key] = opts;\r\n        this.cdr.markForCheck();\r\n      });\r\n    } else if (field.options && !this.isObservable(field.options)) {\r\n      this.filteredOptions[field.key] = (field.options as UiFieldOption[]).filter((o) =>\r\n        o.label.toLowerCase().includes(lowerQuery),\r\n      );\r\n    }\r\n  }\r\n\r\n  /** Display fn per autocomplete. */\r\n  displayFn(options: UiFieldOption[]): (value: any) => string {\r\n    return (value: any) => {\r\n      const opt = options.find((o) => o.value === value);\r\n      return opt?.label || '';\r\n    };\r\n  }\r\n\r\n  /** Seleziona tutte le opzioni per multiselect. */\r\n  selectAll(field: UiFormFieldDescriptor): void {\r\n    const options = this.getFieldOptions(field);\r\n    const allValues = options.filter((o) => !o.disabled).map((o) => o.value);\r\n    this.formGroup.get(field.key)?.setValue(allValues);\r\n  }\r\n\r\n  /** Aggiunge un chip al freemultiselect (da token: Enter o virgola). */\r\n  addFreeChip(field: UiFormFieldDescriptor, event: any): void {\r\n    const value = (event.value || '').trim();\r\n    if (!value) return;\r\n\r\n    const current = this.formGroup.get(field.key)?.value || [];\r\n    if (!current.includes(value)) {\r\n      this.formGroup.get(field.key)?.setValue([...current, value]);\r\n    }\r\n    event.chipInput?.clear();\r\n  }\r\n\r\n  /** Aggiunge un chip al freemultiselect sull'evento blur dell'input. */\r\n  addFreeChipOnBlur(field: UiFormFieldDescriptor, event: FocusEvent): void {\r\n    const input = event.target as HTMLInputElement;\r\n    const value = (input.value || '').trim();\r\n    if (!value) return;\r\n\r\n    const current = this.formGroup.get(field.key)?.value || [];\r\n    if (!current.includes(value)) {\r\n      this.formGroup.get(field.key)?.setValue([...current, value]);\r\n    }\r\n    input.value = '';\r\n  }\r\n\r\n  /** Rimuove un chip dal freemultiselect. */\r\n  removeFreeChip(field: UiFormFieldDescriptor, chipValue: string): void {\r\n    const current = this.formGroup.get(field.key)?.value || [];\r\n    const protected_ = field.metadata?.['cantDeleteList'] || [];\r\n    if (protected_.includes(chipValue)) return;\r\n    this.formGroup.get(field.key)?.setValue(current.filter((v: string) => v !== chipValue));\r\n  }\r\n\r\n  /** Verifica se un chip e protetto dalla cancellazione. */\r\n  isChipProtected(field: UiFormFieldDescriptor, chipValue: string): boolean {\r\n    return (field.metadata?.['cantDeleteList'] || []).includes(chipValue);\r\n  }\r\n\r\n  /** Rimuove chip da multiselect. */\r\n  removeMultiselectChip(field: UiFormFieldDescriptor, chipValue: any): void {\r\n    const current = this.formGroup.get(field.key)?.value || [];\r\n    this.formGroup.get(field.key)?.setValue(current.filter((v: any) => v !== chipValue));\r\n  }\r\n\r\n  /** Trova label di un'opzione dal valore. */\r\n  getOptionLabel(field: UiFormFieldDescriptor, value: any): string {\r\n    const options = this.getFieldOptions(field);\r\n    return options.find((o) => o.value === value)?.label || String(value);\r\n  }\r\n\r\n  /** Tipo di input nativo per il campo. */\r\n  getNativeInputType(field: UiFormFieldDescriptor): string {\r\n    switch (field.type) {\r\n      case 'password':\r\n        return 'password';\r\n      case 'email':\r\n        return 'email';\r\n      default:\r\n        return 'text';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Genera le classi CSS per il wrapper di un campo,\r\n   * combinando eventuali cssClasses dallo schema con le classi\r\n   * responsive per il sistema a griglia base-12.\r\n   *\r\n   * Mobile-first: tutti i campi sono span-12 di default (100%).\r\n   * Le classi `ui-col-{breakpoint}-{n}` attivano la larghezza\r\n   * configurata solo dal breakpoint indicato in su.\r\n   *\r\n   * Breakpoint supportati: sm (≥576px), md (≥768px), lg (≥1024px), xl (≥1280px).\r\n   */\r\n  getFieldWrapperClasses(field: UiFormFieldDescriptor): string {\r\n    const classes: string[] = [];\r\n\r\n    if (field.cssClasses?.length) {\r\n      classes.push(...field.cssClasses);\r\n    }\r\n\r\n    // layout.columns → classe per il breakpoint md (default desktop)\r\n    if (field.layout?.columns) {\r\n      classes.push(`ui-col-md-${field.layout.columns}`);\r\n    }\r\n\r\n    // layout.breakpoints → classi per breakpoint specifici\r\n    if (field.layout?.breakpoints) {\r\n      for (const [bp, cols] of Object.entries(field.layout.breakpoints)) {\r\n        classes.push(`ui-col-${bp}-${cols}`);\r\n      }\r\n    }\r\n\r\n    return classes.join(' ');\r\n  }\r\n\r\n  /** Character count per textarea/text con maxLength. */\r\n  getCharCount(fieldKey: string, fg?: FormGroup): { current: number; max: number } | null {\r\n    const field = this.allFields.find((f) => f.key === fieldKey);\r\n    const maxLength = this.fieldErrorService.resolveMaxLength(field?.validation);\r\n    if (maxLength == null) return null;\r\n\r\n    const target = fg || this.formGroup;\r\n    return this.fieldErrorService.getCharCount(target.get(fieldKey), maxLength);\r\n  }\r\n\r\n  // ─── Utilita private ────────────────────────────────────────────\r\n\r\n  private isObservable(value: any): value is Observable<any> {\r\n    return value && typeof value.subscribe === 'function';\r\n  }\r\n\r\n  getRepeatableAddButtons(section: UiFormSection): UiButtonDescriptor[] {\r\n    return [{\r\n      label: section.repeatable?.addLabel || '+ Aggiungi',\r\n      icon: section.repeatable?.addIcon || 'plus',\r\n      variant: 'outline',\r\n      action: () => this.addRepeatableInstance(section.id)\r\n    }];\r\n  }\r\n}\r\n","<!--\r\n  ============================================================\r\n  UI FORM BUILDER - TEMPLATE PRINCIPALE\r\n  ============================================================\r\n  ARCHITETTURA:\r\n  Ogni <ng-template> che contiene direttive [formControlName]\r\n  DEVE wrappare il proprio contenuto in un <div [formGroup]>.\r\n  Questo perche Angular risolve l'injector di formControlName\r\n  dal CONTESTO DI DICHIARAZIONE del template, non dal punto\r\n  di inserimento (ngTemplateOutlet).\r\n\r\n  Il FormGroup viene passato tramite context per supportare\r\n  sia campi piatti (root FormGroup) che campi in istanze\r\n  repeatable (instance FormGroup).\r\n\r\n  Senza questo wrapper, formControlName non trova il\r\n  FormGroupDirective e lancia NG01050.\r\n  ============================================================\r\n-->\r\n\r\n@if (schema && formGroup) {\r\n<div class=\"ui-form-builder\" [formGroup]=\"formGroup\" [class]=\"schema.config?.cssClasses?.join(' ')\">\r\n\r\n  <!-- ==================== HEADER ==================== -->\r\n  @if (schema.title || schema.description) {\r\n  <div class=\"ui-form-builder__header\">\r\n    @if (schema.title) {\r\n    <h2 class=\"ui-form-builder__title\">{{ schema.title }}</h2>\r\n    }\r\n    @if (schema.description) {\r\n    <p class=\"ui-form-builder__description\">{{ schema.description }}</p>\r\n    }\r\n  </div>\r\n  }\r\n\r\n  <!-- ==================== SEZIONI ==================== -->\r\n  <div class=\"ui-form-builder__sections\">\r\n    @for (section of schema.sections; track section.id) {\r\n    @if (isSectionVisible(section.id)) {\r\n\r\n    <!-- ─── Sezione REPEATABLE ─── -->\r\n    @if (section.repeatable) {\r\n    <div class=\"ui-form-builder__section ui-form-builder__section--repeatable\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <ui-accordion [items]=\"getRepeatableAccordionItems(section.id)\" [itemTemplate]=\"repeatableBodyTpl\"\r\n        [actionsTemplate]=\"repeatableActionsTpl\" mode=\"multi\" class=\"ui-form-builder__repeatable-accordion\">\r\n        <!-- Contenuto di ogni istanza -->\r\n        <ng-template #repeatableBodyTpl let-item>\r\n          <div class=\"ui-form-builder__section-content\"\r\n            [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n            @for (field of section.fields; track field.key) {\r\n            @if (isFieldVisible(field.key, getInstanceFormGroup(section.id, item.index)!) && field.type !== 'flag') {\r\n            <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n              [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n              <ng-container\r\n                *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: getInstanceFormGroup(section.id, item.index), nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key, section.id + '[' + item.index + '].') }\" />\r\n            </div>\r\n            }\r\n            }\r\n          </div>\r\n        </ng-template>\r\n\r\n        <!-- Azioni per ogni istanza (duplica / elimina) -->\r\n        <ng-template #repeatableActionsTpl let-item>\r\n          @if (canAddInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action\"\r\n            (click)=\"duplicateRepeatableInstance(section.id, item.index)\" aria-label=\"Duplica\">\r\n            <lucide-icon name=\"copy\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n          @if (canRemoveInstance(section.id)) {\r\n          <button type=\"button\" class=\"ui-form-builder__repeatable-action ui-form-builder__repeatable-action--danger\"\r\n            (click)=\"removeRepeatableInstance(section.id, item.index)\" aria-label=\"Elimina\">\r\n            <lucide-icon name=\"trash-2\" [size]=\"15\" />\r\n          </button>\r\n          }\r\n        </ng-template>\r\n      </ui-accordion>\r\n\r\n      @if (canAddInstance(section.id)) {\r\n      <div class=\"ui-form-builder__repeatable-add\">\r\n        <ui-button-area [buttons]=\"getRepeatableAddButtons(section)\" align=\"end\" />\r\n      </div>\r\n      }\r\n    </div>\r\n\r\n    <!-- ─── Sezione COLLASSABILE ─── -->\r\n    } @else if (section.collapsible) {\r\n    <ui-accordion [items]=\"getSectionAccordionItems(section.id)\" [itemTemplate]=\"collapsibleTpl\" mode=\"multi\"\r\n      class=\"ui-form-builder__section ui-form-builder__section--collapsible\" [class]=\"section.cssClasses?.join(' ')\">\r\n      <ng-template #collapsibleTpl let-item>\r\n        <div class=\"ui-form-builder__section-content\"\r\n          [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n          @for (field of section.fields; track field.key) {\r\n          @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n          <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n            [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n            <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n          </div>\r\n          }\r\n          }\r\n        </div>\r\n      </ng-template>\r\n    </ui-accordion>\r\n\r\n    <!-- ─── Sezione STANDARD ─── -->\r\n    } @else {\r\n    <div class=\"ui-form-builder__section\" [class]=\"section.cssClasses?.join(' ')\">\r\n      @if (section.title || section.description) {\r\n      <div class=\"ui-form-builder__section-header\">\r\n        @if (section.title) {\r\n        <h3 class=\"ui-form-builder__section-title\">{{ section.title }}</h3>\r\n        }\r\n        @if (section.description) {\r\n        <p class=\"ui-form-builder__section-description\">{{ section.description }}</p>\r\n        }\r\n      </div>\r\n      }\r\n\r\n      <div class=\"ui-form-builder__section-content\"\r\n        [class.ui-form-builder__grid]=\"schema.config?.layout === 'grid' || !schema.config?.layout\">\r\n        @for (field of section.fields; track field.key) {\r\n        @if (isFieldVisible(field.key) && field.type !== 'flag') {\r\n        <div class=\"ui-form-builder__field-wrapper\" [class]=\"getFieldWrapperClasses(field)\"\r\n          [style.order]=\"field.layout?.order || null\" [attr.data-field-key]=\"field.key\">\r\n          <ng-container *ngTemplateOutlet=\"fieldTpl; context: { $implicit: field, formGroup: formGroup, nestedErrorKeyPrefix: buildNestedErrorKeyPrefix(field.key) }\" />\r\n        </div>\r\n        }\r\n        }\r\n      </div>\r\n    </div>\r\n    }\r\n    }\r\n    }\r\n  </div>\r\n\r\n  <!-- ==================== FOOTER ==================== -->\r\n  <div class=\"ui-form-builder__footer\">\r\n    @if (!schema.config?.hideErrorSummary) {\r\n    <ui-form-error-summary [errors]=\"formErrors\" [totalErrorCount]=\"getFormErrorsCount()\"\r\n      [validMessage]=\"schema.config?.errorSummaryValidMessage ?? 'Il form è compilato correttamente'\"\r\n      (fieldClick)=\"scrollToField($event)\" />\r\n    }\r\n    @if (!schema.config?.hideFooter) {\r\n    <ui-button-area [buttons]=\"formButtons\" align=\"end\" [loadingIds]=\"loadingFor\" />\r\n    }\r\n  </div>\r\n</div>\r\n}\r\n\r\n<!-- ============================================================ -->\r\n<!-- FIELD TEMPLATE                                                -->\r\n<!-- ============================================================ -->\r\n<!--\r\n  CRITICO: Questo template e dichiarato FUORI dal <div [formGroup]>.\r\n  Angular risolve l'injector dal contesto di DICHIARAZIONE.\r\n  Il FormGroup viene passato via context (fg) per supportare\r\n  sia il root FormGroup che i FormGroup delle istanze repeatable.\r\n-->\r\n<ng-template #fieldTpl let-field let-fg=\"formGroup\" let-nestedErrorKeyPrefix=\"nestedErrorKeyPrefix\">\r\n  @if (fg) {\r\n  <div [formGroup]=\"fg\" class=\"ui-fb-field-ctx\">\r\n    @switch (field.type) {\r\n\r\n    <!-- TEXT / EMAIL / PASSWORD -->\r\n    @case ('text') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n    @case ('email') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n    @case ('password') {\r\n      <ui-form-text-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- NUMBER -->\r\n    @case ('number') {\r\n      <ui-form-number-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- TEXTAREA -->\r\n    @case ('textarea') {\r\n      <ui-form-textarea-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- SELECT -->\r\n    @case ('select') {\r\n      <ui-form-select-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        (optionsFilter)=\"filterOptions(field, $event)\"\r\n      />\r\n    }\r\n\r\n    <!-- MULTISELECT -->\r\n    @case ('multiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-select [formControlName]=\"field.key\" multiple [placeholder]=\"field.placeholder || ''\">\r\n        @if (field.allowSelectAll) {\r\n        <mat-option (click)=\"selectAll(field)\" (keydown.enter)=\"selectAll(field)\" (keydown.space)=\"selectAll(field)\">\r\n          <em>Seleziona tutto</em>\r\n        </mat-option>\r\n        }\r\n        @for (opt of getFieldOptions(field); track opt.value) {\r\n        <mat-option [value]=\"opt.value\" [disabled]=\"opt.disabled\">\r\n          {{ opt.label }}\r\n        </mat-option>\r\n        }\r\n      </mat-select>\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    @if (fg.get(field.key)?.value?.length) {\r\n    <div class=\"ui-form-builder__chips-preview\">\r\n      @for (val of fg.get(field.key)!.value; track val) {\r\n      <span class=\"ui-form-builder__chip\">\r\n        {{ getOptionLabel(field, val) }}\r\n        <button type=\"button\" (click)=\"removeMultiselectChip(field, val)\" class=\"ui-form-builder__chip-remove\"\r\n          aria-label=\"Rimuovi\">\r\n          <lucide-icon name=\"x\" [size]=\"12\" />\r\n        </button>\r\n      </span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- FREEMULTISELECT -->\r\n    @case ('freemultiselect') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width ui-form-builder__free-multi-field\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <mat-chip-grid #chipGrid [formControlName]=\"field.key\">\r\n        @for (chip of fg.get(field.key)?.value || []; track chip) {\r\n        <mat-chip-row [removable]=\"!isChipProtected(field, chip)\" (removed)=\"removeFreeChip(field, chip)\">\r\n          {{ chip }}\r\n          @if (!isChipProtected(field, chip)) {\r\n          <button matChipRemove aria-label=\"Rimuovi\">\r\n            <lucide-icon name=\"x\" [size]=\"14\" />\r\n          </button>\r\n          }\r\n        </mat-chip-row>\r\n        }\r\n      </mat-chip-grid>\r\n      <input matInput [matChipInputFor]=\"chipGrid\" [placeholder]=\"field.placeholder || 'Aggiungi...'\"\r\n        [readonly]=\"field.readonly || readonly\" (matChipInputTokenEnd)=\"addFreeChip(field, $event)\"\r\n        (blur)=\"addFreeChipOnBlur(field, $event)\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- CHECKBOX -->\r\n    @case ('checkbox') {\r\n    @if (field.appearance?.style === 'switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n    </mat-slide-toggle>\r\n    } @else {\r\n    <mat-checkbox [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-checkbox>\r\n    }\r\n    @if (shouldShowFieldErrors(field.key, fg)) {\r\n    <div class=\"ui-form-builder__field-error\">\r\n      @for (err of getFieldErrors(field.key, fg); track $index) {\r\n      <span>{{ err }}</span>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n\r\n    <!-- SWITCH -->\r\n    @case ('switch') {\r\n    <mat-slide-toggle [formControlName]=\"field.key\" [color]=\"field.appearance?.color || 'primary'\">\r\n      {{ field.label }}\r\n      @if (field.iconTooltip) {\r\n      <lucide-icon [name]=\"field.iconTooltip.icon || 'info'\" [size]=\"14\" [matTooltip]=\"field.iconTooltip.text\"\r\n        class=\"ui-form-builder__inline-tooltip\" />\r\n      }\r\n    </mat-slide-toggle>\r\n    }\r\n\r\n    <!-- RADIO -->\r\n    @case ('radio') {\r\n      <ui-form-radio-field\r\n        [field]=\"field\"\r\n        [formGroup]=\"fg\"\r\n        [readonly]=\"readonly\"\r\n        [errors]=\"getFieldErrors(field.key, fg)\"\r\n        [options]=\"getFieldOptions(field)\"\r\n        [required]=\"isFieldRequired(field.key, fg)\"\r\n        [showErrors]=\"shouldShowFieldErrors(field.key, fg)\"\r\n      />\r\n    }\r\n\r\n    <!-- DATE -->\r\n    @case ('date') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput [matDatepicker]=\"datepicker\" [formControlName]=\"field.key\"\r\n        [placeholder]=\"field.placeholder || 'GG/MM/AAAA'\" [readonly]=\"field.readonly || readonly\" />\r\n      <mat-datepicker-toggle matSuffix [for]=\"datepicker\" />\r\n      <mat-datepicker #datepicker [startView]=\"field.customConfig?.config?.['monthView'] ? 'year' : 'month'\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- DATETIME -->\r\n    @case ('datetime') {\r\n    <mat-form-field appearance=\"outline\" class=\"ui-form-builder__full-width\">\r\n      <mat-label>{{ field.label }}</mat-label>\r\n      <input matInput type=\"datetime-local\" [formControlName]=\"field.key\" [placeholder]=\"field.placeholder || ''\"\r\n        [readonly]=\"field.readonly || readonly\" />\r\n      <mat-error>\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <div>{{ err }}</div>\r\n        }\r\n      </mat-error>\r\n    </mat-form-field>\r\n    }\r\n\r\n    <!-- FILE -->\r\n    @case ('file') {\r\n    <div class=\"ui-form-builder__file-wrapper\">\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      <ui-file-input [formControlName]=\"field.key\" [config]=\"field.fileConfig\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- DIVIDER -->\r\n    @case ('divider') {\r\n    <div class=\"ui-form-builder__divider\">\r\n      @if (field.label) {\r\n      <span class=\"ui-form-builder__divider-label\">{{ field.label }}</span>\r\n      }\r\n      <hr class=\"ui-form-builder__divider-line\" />\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION (selezione territorio) -->\r\n    @case ('location') {\r\n    <div class=\"ui-form-builder__location-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-specifica-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-TABLE (tabella CRUD di location) -->\r\n    @case ('location-table') {\r\n    <div class=\"ui-form-builder__location-table-wrapper\">\r\n      <ui-table-territoriale [formControlName]=\"field.key\" [config]=\"field.customConfig?.config || {}\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- LOCATION-GEOCODED (ricerca indirizzo Nominatim) -->\r\n    @case ('location-geocoded') {\r\n    <div class=\"ui-form-builder__location-geocoded-wrapper\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\" [attr.for]=\"'ui-loc-' + field.key\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      <ui-location-geocoded [formControlName]=\"field.key\" [config]=\"field.locationGeocodedConfig || {}\"\r\n        [placeholder]=\"field.placeholder || 'Cerca indirizzo...'\"\r\n        [inputAriaLabel]=\"field.label || field.placeholder || 'Indirizzo'\"\r\n        [inputId]=\"'ui-loc-' + field.key\"\r\n        [readonly]=\"field.readonly || readonly\"\r\n        [disabled]=\"readonly || field.disabled || disabled\" />\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n\r\n    <!-- CUSTOM -->\r\n    @case ('custom') {\r\n    <div class=\"ui-form-builder__custom-wrapper\" [attr.data-component]=\"field.customConfig?.component\"\r\n      [attr.data-template-key]=\"resolveCustomTemplateKey(field)\">\r\n      @if (field.label) {\r\n      <label class=\"ui-form-builder__field-label\">\r\n        {{ field.label }}\r\n        @if (isFieldRequired(field.key, fg)) { <span class=\"ui-form-builder__required\">*</span> }\r\n      </label>\r\n      }\r\n      @if (getCustomFieldOutlet(field, fg, nestedErrorKeyPrefix); as customOutlet) {\r\n      <ng-container *ngTemplateOutlet=\"customOutlet.template; context: customOutlet.context\" />\r\n      } @else {\r\n      <div class=\"ui-form-builder__custom-placeholder\" role=\"status\">\r\n        <span>Nessun template registrato per «{{ resolveCustomTemplateKey(field) }}»</span>\r\n      </div>\r\n      }\r\n      @if (shouldShowFieldErrors(field.key, fg)) {\r\n      <div class=\"ui-form-builder__field-error\">\r\n        @for (err of getFieldErrors(field.key, fg); track $index) {\r\n        <span>{{ err }}</span>\r\n        }\r\n      </div>\r\n      }\r\n    </div>\r\n    }\r\n    }\r\n  </div>\r\n  }\r\n</ng-template>"]}