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

package/form-builder/lib/components/form-builder/sub-components/form-fields/form-radio-field.component.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { UiFieldErrorDisplayOptions } from '../../services/form-field-error.service';
+import { UiFieldOption, UiFormFieldDescriptor } from '../../types/field.types';
+import { UiValidationRule } from '../../types/validation.types';
+import * as i0 from "@angular/core";
+/**
+
+ * Campo atomico radio group — stesso rendering del form-builder.
+
+ *
+
+ * @selector ui-form-radio-field
+
+ */
+export declare class UiFormRadioFieldComponent {
+    private readonly fieldErrorService;
+    field?: UiFormFieldDescriptor;
+    formGroup?: FormGroup;
+    readonly: boolean;
+    errors: string[] | null;
+    options: UiFieldOption[];
+    /** Indica asterisco obbligatorio (builder: `isFieldRequired`). */
+    required: boolean;
+    /** Override visibilità errori; se null deriva dal controllo. */
+    showErrors: boolean | null;
+    errorDisplayOptions: UiFieldErrorDisplayOptions;
+    control?: FormControl;
+    label?: string;
+    validationRules?: UiValidationRule[];
+    color: 'primary' | 'accent' | 'warn';
+    blurred: EventEmitter<void>;
+    get effectiveLabel(): string;
+    get isDisabled(): boolean;
+    get effectiveOptions(): UiFieldOption[];
+    get effectiveColor(): 'primary' | 'accent' | 'warn';
+    get effectiveRules(): UiValidationRule[];
+    get showRequiredMarker(): boolean;
+    get fieldControl(): FormControl | null;
+    resolvedErrors(control: FormControl | null): string[];
+    shouldShowErrors(control: FormControl | null): boolean;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormRadioFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormRadioFieldComponent, "ui-form-radio-field", never, { "field": { "alias": "field"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "options": { "alias": "options"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showErrors": { "alias": "showErrors"; "required": false; }; "errorDisplayOptions": { "alias": "errorDisplayOptions"; "required": false; }; "control": { "alias": "control"; "required": false; }; "label": { "alias": "label"; "required": false; }; "validationRules": { "alias": "validationRules"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "blurred": "blurred"; }, never, never, true, never>;
+}

package/form-builder/lib/components/form-builder/sub-components/form-fields/form-select-field.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { UiFieldOption, UiFormFieldDescriptor } from '../../types/field.types';
+import { UiValidationRule } from '../../types/validation.types';
+import * as i0 from "@angular/core";
+/**
+
+ * Campo atomico select (mat-select o autocomplete searchable).
+
+ *
+
+ * @selector ui-form-select-field
+
+ */
+export declare class UiFormSelectFieldComponent {
+    private readonly fieldErrorService;
+    field?: UiFormFieldDescriptor;
+    formGroup?: FormGroup;
+    readonly: boolean;
+    errors: string[] | null;
+    options: UiFieldOption[];
+    control?: FormControl;
+    label?: string;
+    placeholder?: string;
+    searchable: boolean;
+    hideEmptyOption: boolean;
+    validationRules?: UiValidationRule[];
+    optionsFilter: EventEmitter<string>;
+    blurred: EventEmitter<void>;
+    get effectiveLabel(): string;
+    get effectivePlaceholder(): string;
+    get isReadonly(): boolean;
+    get isSearchable(): boolean;
+    get showEmptyOption(): boolean;
+    get effectiveOptions(): UiFieldOption[];
+    get effectiveRules(): UiValidationRule[];
+    get fieldControl(): FormControl | null;
+    resolvedErrors(control: FormControl | null): string[];
+    displayWith: (value: unknown) => string;
+    onInput(query: string): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormSelectFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormSelectFieldComponent, "ui-form-select-field", never, { "field": { "alias": "field"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "options": { "alias": "options"; "required": false; }; "control": { "alias": "control"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "hideEmptyOption": { "alias": "hideEmptyOption"; "required": false; }; "validationRules": { "alias": "validationRules"; "required": false; }; }, { "optionsFilter": "optionsFilter"; "blurred": "blurred"; }, never, never, true, never>;
+}

package/form-builder/lib/components/form-builder/sub-components/form-fields/form-text-field.component.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { UiFormFieldDescriptor, UiFieldOption } from '../../types/field.types';
+import { UiValidationRule } from '../../types/validation.types';
+import * as i0 from "@angular/core";
+/**
+ * Campo atomico text / email / password — stesso rendering del form-builder.
+ * Modalità builder: `field` + `formGroup`. Modalità standalone: `control` + `label`.
+ *
+ * @selector ui-form-text-field
+ */
+export declare class UiFormTextFieldComponent {
+    private readonly fieldErrorService;
+    /** Descriptor schema (modalità builder). */
+    field?: UiFormFieldDescriptor;
+    /** FormGroup dell'istanza (modalità builder). */
+    formGroup?: FormGroup;
+    /** Readonly globale dal form-builder. */
+    readonly: boolean;
+    /** Errori pre-calcolati dal builder; se null, derivati dal controllo. */
+    errors: string[] | null;
+    /** Control diretto (modalità standalone / CVA). */
+    control?: FormControl;
+    label?: string;
+    placeholder?: string;
+    maxLength?: number;
+    inputType: 'text' | 'email' | 'password';
+    validationRules?: UiValidationRule[];
+    /** Opzioni autocomplete (campo text searchable nel builder). */
+    options: UiFieldOption[];
+    optionsFilter: EventEmitter<string>;
+    blurred: EventEmitter<void>;
+    /** True se il campo schema è text searchable. */
+    get isSearchableText(): boolean;
+    /** Etichetta effettiva. */
+    get effectiveLabel(): string;
+    /** Placeholder effettivo. */
+    get effectivePlaceholder(): string;
+    /** Tipo input HTML nativo. */
+    get nativeInputType(): string;
+    /** Readonly effettivo sul campo. */
+    get isReadonly(): boolean;
+    /** Controllo risolto per modalità standalone. */
+    get resolvedControl(): FormControl | null;
+    /** Regole validation per messaggi errore. */
+    get effectiveRules(): UiValidationRule[];
+    /** Max length da regole o input. */
+    get effectiveMaxLength(): number | undefined;
+    /** Controllo del campo in modalità builder. */
+    get fieldControl(): FormControl | null;
+    /** Messaggi errore da mostrare in mat-error. */
+    resolvedErrors(control: FormControl | null): string[];
+    /** Conteggio caratteri (solo text con maxLength). */
+    charCount(control: FormControl | null): {
+        current: number;
+        max: number;
+    } | null;
+    onInput(query: string): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormTextFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormTextFieldComponent, "ui-form-text-field", never, { "field": { "alias": "field"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "control": { "alias": "control"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "validationRules": { "alias": "validationRules"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "optionsFilter": "optionsFilter"; "blurred": "blurred"; }, never, never, true, never>;
+}

package/form-builder/lib/components/form-builder/sub-components/form-fields/form-textarea-field.component.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { UiFormFieldDescriptor } from '../../types/field.types';
+import { UiValidationRule } from '../../types/validation.types';
+import * as i0 from "@angular/core";
+/**
+ * Campo atomico textarea — stesso rendering del form-builder.
+ *
+ * @selector ui-form-textarea-field
+ */
+export declare class UiFormTextareaFieldComponent {
+    private readonly fieldErrorService;
+    field?: UiFormFieldDescriptor;
+    formGroup?: FormGroup;
+    readonly: boolean;
+    errors: string[] | null;
+    control?: FormControl;
+    label?: string;
+    placeholder?: string;
+    rows: number;
+    maxLength?: number;
+    validationRules?: UiValidationRule[];
+    blurred: EventEmitter<void>;
+    get effectiveLabel(): string;
+    get effectivePlaceholder(): string;
+    get isReadonly(): boolean;
+    get effectiveRules(): UiValidationRule[];
+    /** Controllo del campo in modalità builder. */
+    get fieldControl(): FormControl | null;
+    get effectiveMaxLength(): number | undefined;
+    resolvedErrors(control: FormControl | null): string[];
+    charCount(control: FormControl | null): {
+        current: number;
+        max: number;
+    } | null;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormTextareaFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormTextareaFieldComponent, "ui-form-textarea-field", never, { "field": { "alias": "field"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "control": { "alias": "control"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "validationRules": { "alias": "validationRules"; "required": false; }; }, { "blurred": "blurred"; }, never, never, true, never>;
+}

package/form-builder/lib/components/form-builder/sub-components/form-fields/index.d.ts

@@ -0,0 +1,5 @@
+export { UiFormTextFieldComponent } from './form-text-field.component';
+export { UiFormTextareaFieldComponent } from './form-textarea-field.component';
+export { UiFormNumberFieldComponent } from './form-number-field.component';
+export { UiFormSelectFieldComponent } from './form-select-field.component';
+export { UiFormRadioFieldComponent } from './form-radio-field.component';

package/form-builder/lib/components/form-builder/sub-components/location-geocoded/location-geocoded.component.d.ts

@@ -0,0 +1,84 @@
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import type { UiGeocodedLocationInput, UiGeocodedLocationType, UiLocationGeocodedFieldConfig } from '../../types/geocoded-location.types';
+import * as i0 from "@angular/core";
+/** Stati UI per hint e messaggi accessibili. */
+type UiGeocodedPanelState = 'idle' | 'loading' | 'results' | 'empty' | 'error';
+/**
+ * Campo indirizzo con ricerca geocodificata (Nominatim) e selezione atomica da autocomplete.
+ * Implementa `ControlValueAccessor`; il valore è {@link UiGeocodedLocationType} o `null`.
+ *
+ * L'applicazione host deve fornire `provideHttpClient()` (o `HttpClient` equivalente).
+ */
+export declare class UiLocationGeocodedComponent implements ControlValueAccessor, OnInit {
+    private readonly nominatim;
+    private readonly cdr;
+    private readonly destroyRef;
+    private readonly document;
+    /** Configurazione ricerca (URL base, debounce, limiti). */
+    config: UiLocationGeocodedFieldConfig;
+    /** Placeholder dell'input. */
+    placeholder: string;
+    /** Etichetta accessibile dell'input (se la label visibile è esterna al componente). */
+    inputAriaLabel: string;
+    /** `id` HTML dell'input (per associare la label esterna con `for`). */
+    inputId: string;
+    /** Disabilita il campo. */
+    set disabled(v: boolean);
+    get disabled(): boolean;
+    /** Input in sola lettura (testo non modificabile). */
+    readonly: boolean;
+    /** Trigger Material: serve a non trattare il blur verso il pannello come uscita senza selezione. */
+    private autoTrigger?;
+    /** Testo digitabile e label selezionata (sempre stringa, compatibile con MatAutocomplete). */
+    readonly searchControl: FormControl<string>;
+    /** Suggerimenti correnti per il pannello autocomplete. */
+    suggestions: UiGeocodedLocationType[];
+    /** Ultima query usata per evidenziare i match nel pannello. */
+    lastQueryForHighlight: string;
+    panelState: UiGeocodedPanelState;
+    private _disabled;
+    private selected;
+    /** Evita che la selezione da autocomplete venga trattata come cancellazione del valore. */
+    private selecting;
+    /** `pointerdown` sul pannello overlay (fase capture): il blur dell'input avviene prima del click; senza questo si azzera il valore. */
+    private pointerDownOnOverlay;
+    private readonly resultCache;
+    private readonly maxCacheEntries;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    private pushCache;
+    onOptionSelected(event: MatAutocompleteSelectedEvent): void;
+    /**
+     * Chiusura focus sull'input: differita così `optionSelected` può aggiornare il modello prima di eventuale reset.
+     * `pointerDownOnOverlay` copre il caso blur → click sulla lista (relatedTarget spesso null).
+     */
+    onBlur(event: FocusEvent): void;
+    /** Imposta il flag prima del blur quando l'utente preme sul pannello (stesso gesto del click su `mat-option`). */
+    private onDocumentPointerDown;
+    /**
+     * Identità stabile per `@for` sui suggerimenti (evita `??` nel template e problemi di codegen).
+     */
+    trackSuggestion(opt: UiGeocodedLocationType): string;
+    /** Segmenta la label per evidenziazione accessibile (match letterale case-insensitive). */
+    highlightParts(label: string): {
+        text: string;
+        highlight: boolean;
+    }[];
+    /** Messaggio per `aria-live` in base allo stato del pannello. */
+    getStatusMessage(): string;
+    writeValue(value: UiGeocodedLocationInput | null): void;
+    registerOnChange(fn: (v: UiGeocodedLocationType | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private syncDisabled;
+    /**
+     * Completa `territory` e gli slice `italian` / `foreign` se assenti (payload legacy o altri provider).
+     */
+    private ensureTerritory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLocationGeocodedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiLocationGeocodedComponent, "ui-location-geocoded", never, { "config": { "alias": "config"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "inputAriaLabel": { "alias": "inputAriaLabel"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/form-builder/lib/components/form-builder/sub-components/specifica-territoriale/specifica-territoriale.component.d.ts

@@ -0,0 +1,145 @@
+import { OnInit, OnDestroy, ChangeDetectorRef, Injector } from '@angular/core';
+import { ControlValueAccessor, FormBuilder, FormGroup, AbstractControl, ValidationErrors, Validator, NgControl } from '@angular/forms';
+import { UiLocationService, UiNazione, UiProvincia, UiComune } from '../../services/location.service';
+import { UiLocationConfig, UiLocationValue } from '../../types/territoriale.types';
+import * as i0 from "@angular/core";
+/**
+ * Interfaccia interna per i CAP nel componente.
+ */
+interface UiCapOption {
+    /** ID del CAP. */
+    id: string;
+    /** Codice CAP visualizzato. */
+    codice: string;
+    /** ID del comune associato. */
+    comuneId: string;
+}
+/**
+ * Componente standalone per la selezione di dati geografici italiani o esteri.
+ *
+ * Supporta due modalita:
+ * - **Italia**: selezione a cascata nazione -> provincia -> comune -> CAP
+ * - **Estero**: selezione nazione + campo testo libero per il comune
+ *
+ * Campi opzionali configurabili: indirizzo, mail, PEC, telefono.
+ *
+ * Implementa `ControlValueAccessor` e `Validator` per l'integrazione
+ * diretta con Angular Reactive Forms.
+ *
+ * Utilizza dati da JSON statici tramite `UiLocationService`
+ * (nessuna dipendenza al backend).
+ *
+ * @selector ui-specifica-territoriale
+ *
+ * @example
+ * ```html
+ * <ui-specifica-territoriale
+ *   [formControl]="myControl"
+ *   [config]="{ italyByDefault: true, cap: { show: true } }"
+ * />
+ * ```
+ */
+export declare class UiSpecificaTerritorialeComponent implements ControlValueAccessor, Validator, OnInit, OnDestroy {
+    private readonly fb;
+    private readonly injector;
+    private readonly cdr;
+    private readonly locationService;
+    /** Configurazione del componente. */
+    config: UiLocationConfig;
+    /** Stato disabilitato globale. */
+    disabled: boolean;
+    private readonly EMAIL_PATTERN;
+    private readonly PEC_PATTERN;
+    private readonly PHONE_PATTERN;
+    form: FormGroup;
+    isItalian: boolean;
+    isForeign: boolean;
+    ngControl: NgControl;
+    /** Elenco nazioni disponibili. */
+    nazioni: UiNazione[];
+    /** Elenco province disponibili. */
+    province: UiProvincia[];
+    /** Comuni filtrati per la provincia selezionata. */
+    filteredComuni: UiComune[];
+    /** CAP filtrati per il comune selezionato. */
+    filteredCaps: UiCapOption[];
+    /** Promise di inizializzazione (utile per test e table-territoriale). */
+    initializationPromise: Promise<void> | null;
+    private readonly destroy$;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    private subscriptionsInitialized;
+    private pendingWriteValue;
+    private isInitializing;
+    private tipologicheLoaded;
+    constructor(fb: FormBuilder, injector: Injector, cdr: ChangeDetectorRef, locationService: UiLocationService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: UiLocationValue | null): void;
+    registerOnChange(fn: (value: UiLocationValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    registerOnValidatorChange(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(_control: AbstractControl): ValidationErrors | null;
+    /** Marca tutti i controlli interni come touched. */
+    markAsTouched(): void;
+    /** Verifica se mostrare gli errori per un campo interno. */
+    shouldShowFieldErrors(fieldKey: string): boolean;
+    /** Errori di un campo interno come array di messaggi. */
+    getFieldErrors(fieldKey: string): string[];
+    /** Handler blur per propagare il touched. */
+    onBlur(): void;
+    /** Resetta lo stato del componente. */
+    resetComponentState(): void;
+    /** Labels personalizzabili con valori di default. */
+    get labels(): {
+        nazione: string;
+        provincia: string;
+        comune: string;
+        cap: string;
+        indirizzo: string;
+        comuneEstero: string;
+        mail: string;
+        pec: string;
+        telefono: string;
+    };
+    get hasValidationErrors(): boolean;
+    get validationErrors(): string[];
+    get showCAP(): boolean;
+    get showIndirizzo(): boolean;
+    get showMail(): boolean;
+    get showPEC(): boolean;
+    get showTelefono(): boolean;
+    get capColumns(): number;
+    get indirizzoColumns(): number;
+    get mailColumns(): number;
+    get pecColumns(): number;
+    get telefonoColumns(): number;
+    get isItalyByDefault(): boolean;
+    get isCapDisabled(): boolean;
+    get isNazioneDisabled(): boolean;
+    get isRequired(): boolean;
+    private initializeComponent;
+    private initializeForm;
+    private setupNgControl;
+    private loadLocationData;
+    private processWriteValue;
+    private handleItalyByDefaultValue;
+    private setupFormSubscriptions;
+    private handleTerritorialChanges;
+    private updateNationalityState;
+    private updateTerritorialData;
+    private updateFilteredComuni;
+    private updateFilteredCaps;
+    private updateComponentState;
+    private applyFieldsDisabledState;
+    private updateValidators;
+    private applyContactValidators;
+    private validateContactFields;
+    private applyInitialConfiguration;
+    private notifyValidationChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiSpecificaTerritorialeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiSpecificaTerritorialeComponent, "ui-specifica-territoriale", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/form-builder/lib/components/form-builder/sub-components/table-territoriale/table-territoriale.component.d.ts

@@ -0,0 +1,108 @@
+import { OnInit, OnDestroy, OnChanges, SimpleChanges, ChangeDetectorRef, Injector } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, NgControl } from '@angular/forms';
+import { MatTableDataSource } from '@angular/material/table';
+import { UiSpecificaTerritorialeComponent } from '../specifica-territoriale/specifica-territoriale.component';
+import { UiLocationService } from '../../services/location.service';
+import { UiButtonDescriptor } from '../../../button/index';
+import { UiLocationTableConfig, UiLocationRow } from '../../types/territoriale.types';
+import * as i0 from "@angular/core";
+/**
+ * Componente standalone per la gestione tabellare di location multiple.
+ *
+ * Permette l'inserimento, la modifica e l'eliminazione di righe
+ * territoriali (italiane o estere) tramite una tabella Material
+ * con form inline basato su `UiSpecificaTerritorialeComponent`.
+ *
+ * Implementa `ControlValueAccessor` e `Validator` per l'integrazione
+ * con Angular Reactive Forms. Il valore e un array di `UiLocationRow`.
+ *
+ * @selector ui-table-territoriale
+ *
+ * @example
+ * ```html
+ * <ui-table-territoriale
+ *   [formControl]="sedeControl"
+ *   [config]="{
+ *     tableLabel: 'Sedi operative',
+ *     subFieldConfig: { italyByDefault: true, cap: { show: true } }
+ *   }"
+ * />
+ * ```
+ */
+export declare class UiTableTerritorialeComponent implements ControlValueAccessor, Validator, OnInit, OnDestroy, OnChanges {
+    private readonly cdr;
+    private readonly injector;
+    private readonly locationService;
+    /** Configurazione della tabella. */
+    config: UiLocationTableConfig;
+    /** Stato disabilitato globale. */
+    disabled: boolean;
+    /** Righe della tabella. */
+    rows: UiLocationRow[];
+    /** DataSource Material per la tabella. */
+    dataSource: MatTableDataSource<UiLocationRow, import("@angular/material/paginator").MatPaginator>;
+    /** Modalita editing attiva. */
+    editMode: boolean;
+    /** Modalita inserimento attiva. */
+    insertMode: boolean;
+    /** Riga in modifica. */
+    editingRow: UiLocationRow | null;
+    /** Indice della riga in modifica. */
+    editingIndex: number | null;
+    /** Colonne visualizzate nella tabella. */
+    displayedColumns: string[];
+    /** Configurazione delle colonne. */
+    columnConfig: Record<string, {
+        label: string;
+        show: boolean;
+    }>;
+    /** Pulsanti per il form di inserimento/modifica. */
+    formButtons: UiButtonDescriptor[];
+    /** Pulsante per aggiungere una nuova riga. */
+    addButton: UiButtonDescriptor[];
+    /** NgControl per accedere alla validazione del form parent. */
+    ngControl: NgControl | null;
+    specificaForm: UiSpecificaTerritorialeComponent;
+    private readonly destroy$;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    constructor(cdr: ChangeDetectorRef, injector: Injector, locationService: UiLocationService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    writeValue(value: UiLocationRow[] | null): void;
+    registerOnChange(fn: (value: UiLocationRow[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    get isRequired(): boolean;
+    get hasValidationErrors(): boolean;
+    get validationErrors(): string[];
+    private initializeColumns;
+    /** Attiva la modalita inserimento. */
+    activateInsertMode(): void;
+    /** Attiva la modalita modifica per una riga. */
+    editRow(row: UiLocationRow, index: number): void;
+    /** Annulla l'operazione in corso (inserimento o modifica). */
+    cancelEdit(): void;
+    /** Rimuove una riga dalla tabella. */
+    removeRow(index: number): void;
+    /** Salva la riga corrente (nuova o in modifica). */
+    saveRow(): Promise<void>;
+    /** Marca il componente come touched. */
+    markAsTouched(): void;
+    /** Resetta lo stato del componente. */
+    resetComponentState(): void;
+    /** Funzione track by per la tabella. */
+    trackByFn(_index: number, item: UiLocationRow): string;
+    private mapRowToFormValue;
+    private mapFormValueToRow;
+    private propagateChange;
+    private generateUUID;
+    private calculateActions;
+    private calculateFormButtons;
+    private calculateAddButton;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiTableTerritorialeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiTableTerritorialeComponent, "ui-table-territoriale", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/form-builder/lib/components/form-builder/types/condition.types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module ng-ui-system/form-builder
+ * Tipi per il sistema di condizioni (visibilita, required, disable).
+ */
+/**
+ * Operatori di confronto supportati dal sistema di condizioni.
+ *
+ * | Operatore        | Descrizione                                |
+ * |------------------|--------------------------------------------|
+ * | `equals`         | Uguale a `value`                           |
+ * | `not_equals`     | Diverso da `value`                         |
+ * | `contains`       | La stringa contiene `value`                |
+ * | `not_contains`   | La stringa non contiene `value`            |
+ * | `greater_than`   | Maggiore di `value` (numerico)             |
+ * | `less_than`      | Minore di `value` (numerico)               |
+ * | `greater_equal`  | Maggiore o uguale a `value`                |
+ * | `less_equal`     | Minore o uguale a `value`                  |
+ * | `is_empty`       | Il campo e vuoto/null/undefined            |
+ * | `is_not_empty`   | Il campo ha un valore non vuoto            |
+ * | `in_array`       | Il valore e presente nell'array `value`    |
+ * | `not_in_array`   | Il valore non e presente nell'array `value`|
+ */
+export type UiConditionalOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_equal' | 'less_equal' | 'is_empty' | 'is_not_empty' | 'in_array' | 'not_in_array';
+/**
+ * Condizione per il rendering condizionale dei campi.
+ *
+ * Piu condizioni possono essere combinate con logica AND/OR.
+ * Default: AND (tutte le condizioni devono essere vere).
+ *
+ * @example
+ * ```typescript
+ * // Campo visibile solo se 'tipo' == 'persona-fisica'
+ * conditions: [{ field: 'tipo', operator: 'equals', value: 'persona-fisica' }]
+ *
+ * // Combinazione AND/OR
+ * conditions: [
+ *   { field: 'stato', operator: 'equals', value: 'attivo', logic: 'AND' },
+ *   { field: 'ruolo', operator: 'in_array', value: ['admin', 'editor'] },
+ * ]
+ * ```
+ */
+export interface UiFieldCondition {
+    /** Chiave del campo da valutare. Supporta dot notation (es. `'address.city'`). */
+    field: string;
+    /** Operatore di confronto. */
+    operator: UiConditionalOperator;
+    /** Valore di confronto (opzionale per `is_empty`/`is_not_empty`). */
+    value?: any;
+    /** Logica di combinazione con le altre condizioni. @default 'AND' */
+    logic?: 'AND' | 'OR';
+}