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

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

@@ -0,0 +1,170 @@
+/**
+ * @module ng-ui-system/form-builder
+ * Tipi per i componenti di selezione territoriale (location e location-table).
+ */
+/**
+ * Configurazione per un sotto-campo del componente location.
+ * Permette di controllare visibilita, obbligatorieta e layout.
+ */
+export interface UiLocationFieldConfig {
+    /** Mostra il campo. @default true per nazione/provincia/comune, false per campi opzionali */
+    show?: boolean;
+    /** Rende il campo obbligatorio. */
+    required?: boolean;
+    /** Numero di colonne nella griglia (1-12). */
+    columns?: number;
+}
+/**
+ * Configurazione completa per il componente `UiSpecificaTerritorialeComponent`.
+ *
+ * Permette di personalizzare ogni aspetto della selezione geografica:
+ * campi visibili, obbligatorieta, layout e labels.
+ *
+ * @example
+ * ```typescript
+ * // Configurazione base: solo nazione, provincia, comune
+ * const config: UiLocationConfig = {
+ *   nazione: { required: true },
+ *   provincia: { required: true },
+ *   comune: { required: true },
+ * };
+ *
+ * // Con campi aggiuntivi
+ * const configEsteso: UiLocationConfig = {
+ *   italyByDefault: true,
+ *   cap: { show: true, required: true, columns: 4 },
+ *   indirizzo: { show: true, required: true, columns: 8 },
+ *   mail: { show: true, columns: 6 },
+ *   pec: { show: true, columns: 6 },
+ *   telefono: { show: true, columns: 6 },
+ * };
+ * ```
+ */
+export interface UiLocationConfig {
+    /** Configurazione campo nazione. Required default: true. */
+    nazione?: {
+        required?: boolean;
+    };
+    /** Configurazione campo provincia. Required default: true. */
+    provincia?: {
+        required?: boolean;
+    };
+    /** Configurazione campo comune. Required default: true. */
+    comune?: {
+        required?: boolean;
+    };
+    /** Configurazione campo comune estero. Required default: true. */
+    comuneEstero?: {
+        required?: boolean;
+    };
+    /** Configurazione campo CAP. Show default: false. */
+    cap?: UiLocationFieldConfig;
+    /** Configurazione campo indirizzo. Show default: false. */
+    indirizzo?: UiLocationFieldConfig;
+    /** Configurazione campo email. Show default: false. */
+    mail?: UiLocationFieldConfig;
+    /** Configurazione campo PEC. Show default: false. */
+    pec?: UiLocationFieldConfig;
+    /** Configurazione campo telefono. Show default: false. */
+    telefono?: UiLocationFieldConfig;
+    /** Pre-imposta l'Italia come nazione e nasconde la select. */
+    italyByDefault?: boolean;
+    /** Labels personalizzate per i campi. */
+    labels?: UiLocationLabels;
+}
+/**
+ * Labels personalizzabili per i campi del componente location.
+ */
+export interface UiLocationLabels {
+    nazione?: string;
+    provincia?: string;
+    comune?: string;
+    cap?: string;
+    indirizzo?: string;
+    comuneEstero?: string;
+    mail?: string;
+    pec?: string;
+    telefono?: string;
+}
+/**
+ * Valore emesso dal componente location.
+ * Contiene gli ID dei dati geografici selezionati e i campi testuali.
+ */
+export interface UiLocationValue {
+    /** Codice nazione (es. `'ITA'`). */
+    nazioneId?: string;
+    /** Codice provincia (es. `'015'`). */
+    provinciaId?: string;
+    /** Codice comune (es. `'015146'`). */
+    comuneId?: string;
+    /** Codice di avviamento postale. */
+    cap?: string;
+    /** Indirizzo completo (via, numero civico). */
+    indirizzo?: string;
+    /** Nome del comune per nazioni estere (testo libero). */
+    comuneEstero?: string;
+    /** Indirizzo email. */
+    mail?: string;
+    /** Indirizzo PEC. */
+    pec?: string;
+    /** Numero di telefono. */
+    telefono?: string;
+}
+/**
+ * Configurazione per il componente `UiTableTerritorialeComponent`.
+ *
+ * Gestisce una tabella di righe territoriali con CRUD inline.
+ *
+ * @example
+ * ```typescript
+ * const tableConfig: UiLocationTableConfig = {
+ *   tableLabel: 'Sedi operative',
+ *   emptyPrompt: 'Nessuna sede aggiunta',
+ *   emptyCtaLabel: 'Aggiungi sede',
+ *   requiredMessage: 'Inserire almeno una sede',
+ *   subFieldConfig: {
+ *     italyByDefault: true,
+ *     cap: { show: true, required: true },
+ *     indirizzo: { show: true, required: true },
+ *   },
+ * };
+ * ```
+ */
+export interface UiLocationTableConfig {
+    /** Label della tabella. @default 'Tabella territoriale' */
+    tableLabel?: string;
+    /** Label del pulsante di aggiunta. @default 'Aggiungi un luogo' */
+    emptyCtaLabel?: string;
+    /** Testo mostrato quando la tabella e vuota. */
+    emptyPrompt?: string;
+    /** Messaggio di errore quando la tabella e richiesta ma vuota. */
+    requiredMessage?: string;
+    /** Configurazione per il sotto-form (specifica territoriale). */
+    subFieldConfig?: UiLocationConfig;
+}
+/**
+ * Riga della tabella territoriale.
+ * Contiene dati completi della location (oggetti risolti dal servizio).
+ */
+export interface UiLocationRow {
+    /** Nazione (oggetto completo). */
+    stato: any;
+    /** Provincia (solo per Italia). */
+    provincia?: any;
+    /** Comune italiano (oggetto completo). */
+    comuni?: any;
+    /** Comuni esteri (array di nomi). */
+    comuniEsteri?: string[];
+    /** Codice di avviamento postale. */
+    cap?: string;
+    /** Indirizzo completo. */
+    indirizzo?: string;
+    /** Indirizzo email. */
+    mail?: string;
+    /** PEC. */
+    pec?: string;
+    /** Numero di telefono. */
+    telefono?: string;
+    /** ID univoco per il tracciamento della riga. */
+    refId?: string;
+}

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

@@ -0,0 +1,174 @@
+/**
+ * @module ng-ui-system/form-builder
+ * Tipi relativi alla validazione dei campi.
+ */
+import { ValidatorFn } from '@angular/forms';
+import { UiFieldCondition } from './condition.types';
+/**
+ * Operatori di confronto per validazioni cross-field.
+ */
+export type UiCrossFieldOperator = 'greater_than' | 'greater_equal' | 'less_than' | 'less_equal' | 'not_equal';
+/**
+ * Configurazione per validazione cross-field.
+ * Confronta il valore del campo corrente con quello di un altro campo.
+ *
+ * @example
+ * ```typescript
+ * // La data di fine deve essere successiva alla data di inizio
+ * crossField: {
+ *   targetField: 'data-inizio',
+ *   operator: 'greater_than',
+ *   dataType: 'date',
+ * }
+ * ```
+ */
+export interface UiCrossFieldConfig {
+    /** Chiave del campo di confronto. */
+    targetField: string;
+    /** Operatore di confronto. */
+    operator: UiCrossFieldOperator;
+    /** Tipo di dato per il confronto. */
+    dataType: 'date' | 'number';
+    /** Per le date, specifica se il formato e MM/YYYY. */
+    isMonthYear?: boolean;
+}
+/**
+ * Keyword predefinite per date di riferimento.
+ */
+export type UiDateKeyword = 'today' | 'tomorrow' | 'yesterday';
+/**
+ * Configurazione per validazione date-min / date-max.
+ * Permette di validare che una data sia precedente o successiva
+ * a un valore di riferimento, con supporto per offset temporali.
+ *
+ * @example
+ * ```typescript
+ * // Data deve essere >= oggi
+ * { type: 'date-min', value: 'today', message: 'La data deve essere futura' }
+ *
+ * // Data deve essere <= oggi + 1 anno
+ * { type: 'date-max', value: 'today', offset: '1y', message: 'Max 1 anno da oggi' }
+ *
+ * // Data deve essere >= una data specifica
+ * { type: 'date-min', value: '01/01/2024', message: 'Almeno dal 2024' }
+ * ```
+ */
+export interface UiDateValidationConfig {
+    /**
+     * Data di riferimento.
+     * Puo essere una keyword (`'today'`, `'tomorrow'`, `'yesterday'`)
+     * o una data nel formato `DD/MM/YYYY`.
+     */
+    value: string | UiDateKeyword;
+    /**
+     * Offset da applicare alla data di riferimento.
+     *
+     * Formato: `numero + unita`
+     * - `'y'` o `'a'` per anni (es. `'1y'`, `'2a'`)
+     * - `'m'` per mesi (es. `'6m'`, `'12m'`)
+     * - `'g'` o `'d'` per giorni (es. `'30g'`, `'7d'`)
+     * - `'w'` per settimane (es. `'2w'`)
+     */
+    offset?: string;
+}
+/**
+ * Tipi di validazione supportati dal form builder.
+ *
+ * | Tipo         | Valore atteso      | Descrizione                             |
+ * |-------------|--------------------|-----------------------------------------|
+ * | `required`  | —                  | Campo obbligatorio                      |
+ * | `email`     | —                  | Formato email valido                    |
+ * | `min`       | `number`           | Valore numerico minimo                  |
+ * | `max`       | `number`           | Valore numerico massimo                 |
+ * | `minLength` | `number`           | Lunghezza minima stringa                |
+ * | `maxLength` | `number`           | Lunghezza massima stringa               |
+ * | `pattern`   | `string` (regex)   | Pattern regex da rispettare             |
+ * | `custom`    | `ValidatorFn`      | Validatore Angular custom               |
+ * | `crossField`| `CrossFieldConfig` | Confronto con un altro campo            |
+ * | `date-min`  | `string`           | Data minima (keyword o DD/MM/YYYY)      |
+ * | `date-max`  | `string`           | Data massima (keyword o DD/MM/YYYY)     |
+ * | `fileSize`  | `number` (bytes)   | Dimensione massima file                 |
+ * | `fileType`  | `string[]` (MIME)  | Tipi file accettati                     |
+ * | `fileCount` | `number`           | Numero massimo file                     |
+ */
+export type UiValidationType = 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'custom' | 'crossField' | 'date-min' | 'date-max' | 'fileSize' | 'fileType' | 'fileCount';
+/**
+ * Regola di validazione per un campo del form.
+ *
+ * Supporta validazioni standard, cross-field, date con offset,
+ * file e validatori custom Angular. Ogni regola puo avere
+ * condizioni che ne controllano l'applicazione.
+ *
+ * @example
+ * ```typescript
+ * // Validazione required condizionale
+ * {
+ *   type: 'required',
+ *   message: 'Campo obbligatorio se attivo',
+ *   conditions: [{ field: 'is-active', operator: 'equals', value: true }],
+ * }
+ *
+ * // Validazione cross-field
+ * {
+ *   type: 'crossField',
+ *   crossField: {
+ *     targetField: 'eta-minima',
+ *     operator: 'greater_than',
+ *     dataType: 'number',
+ *   },
+ *   message: "L'eta massima deve essere maggiore dell'eta minima",
+ * }
+ * ```
+ */
+export interface UiValidationRule {
+    /** Tipo di validazione. */
+    type: UiValidationType;
+    /**
+     * Valore per la validazione.
+     * - Per `min`/`max`: valore numerico
+     * - Per `minLength`/`maxLength`: lunghezza
+     * - Per `pattern`: stringa regex
+     * - Per `date-min`/`date-max`: keyword o data `DD/MM/YYYY`
+     * - Per `fileSize`: dimensione in bytes
+     * - Per `fileType`: array di MIME types
+     * - Per `fileCount`: numero massimo file
+     */
+    value?: any;
+    /**
+     * Offset temporale per `date-min`/`date-max`.
+     * @see UiDateValidationConfig.offset
+     */
+    offset?: string;
+    /** Configurazione per validazione cross-field. */
+    crossField?: UiCrossFieldConfig;
+    /** Messaggio di errore personalizzato. */
+    message?: string;
+    /** Funzione validatore Angular custom (per `type: 'custom'`). */
+    validator?: ValidatorFn;
+    /** Condizioni per applicare questa regola (validazione condizionale). */
+    conditions?: UiFieldCondition[];
+}
+/**
+ * Stato di validazione complessivo del form.
+ */
+export interface UiFormValidationState {
+    /** Se il form e valido. */
+    valid: boolean;
+    /** Mappa errori per chiave campo. */
+    errors: Record<string, string[]>;
+    /** Chiavi dei campi modificati. */
+    dirty: string[];
+    /** Chiavi dei campi toccati. */
+    touched: string[];
+}
+/**
+ * Dettaglio di un errore per l'error summary.
+ */
+export interface UiFormErrorDetail {
+    /** Chiave del campo in errore. */
+    fieldKey: string;
+    /** Label del campo per visualizzazione. */
+    fieldLabel: string;
+    /** Lista messaggi di errore. */
+    errors: string[];
+}

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

@@ -0,0 +1,117 @@
+/**
+ * @module ng-ui-system/form-builder-editor
+ * Componente principale dell'editor visuale del form builder.
+ *
+ * Layout a tre pannelli:
+ * - Sinistra: palette dei tipi di campo (drag source)
+ * - Centro: sezioni con campi (drop target + editor inline)
+ * - Destra: pannello di configurazione del campo selezionato
+ *
+ * Funzionalita principali:
+ * - Drag & drop dei campi dalla palette alle sezioni
+ * - Riordino campi all'interno e tra sezioni
+ * - Configurazione campi in tempo reale
+ * - Preview live del form
+ * - Import/export JSON
+ * - Auto-save su localStorage
+ */
+import { OnInit, OnDestroy } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { MatDialogRef } from '@angular/material/dialog';
+import { UiFormFieldDescriptor } from '../form-builder/types/index';
+import { UiEditorState, UiEditorBreadcrumbItem, UiEditorAvailableField, UiEditorDialogData } from './types/editor.types';
+import { UiEditorStateService } from './services/editor-state.service';
+import * as i0 from "@angular/core";
+export declare class UiFormBuilderEditorComponent implements OnInit, OnDestroy {
+    dialogRef: MatDialogRef<UiFormBuilderEditorComponent>;
+    dialogData: UiEditorDialogData;
+    /** @internal Servizio per lo stato dell'editor. */
+    readonly stateService: UiEditorStateService;
+    /** @internal Servizio per la persistenza. */
+    private readonly persistenceService;
+    /** @internal Factory per i campi. */
+    private readonly fieldFactory;
+    /** @internal Snack bar per i messaggi. */
+    private readonly snackBar;
+    /** @internal Change detector. */
+    private readonly cdr;
+    /** @internal Subject per la distruzione. */
+    private readonly destroy$;
+    /** Stato corrente dell'editor. */
+    state: UiEditorState;
+    /** Indice del tab selezionato (0=Editor, 1=Preview). */
+    selectedTabIndex: number;
+    /** Breadcrumb di navigazione. */
+    breadcrumb: UiEditorBreadcrumbItem[];
+    /** Se il componente e aperto in modalita dialog. */
+    isDialogMode: boolean;
+    /** Chiave per forzare il re-render del preview. */
+    previewKey: number;
+    /** Campi disponibili per le condizioni (cache). */
+    availableFields: UiEditorAvailableField[];
+    /** Larghezza della sidebar sinistra (px). */
+    leftSidebarWidth: number;
+    /** Larghezza della sidebar destra (px). */
+    rightSidebarWidth: number;
+    /** Se e in corso il resize della sidebar destra. */
+    isResizing: boolean;
+    /** Se e in corso il resize della sidebar sinistra. */
+    isResizingLeft: boolean;
+    /** @internal Limiti di resize sidebar destra. */
+    private readonly MIN_SIDEBAR_WIDTH;
+    private readonly MAX_SIDEBAR_WIDTH;
+    /** @internal Limiti di resize sidebar sinistra. */
+    private readonly MIN_LEFT_SIDEBAR_WIDTH;
+    private readonly MAX_LEFT_SIDEBAR_WIDTH;
+    private resizeStartX;
+    private resizeStartWidth;
+    private readonly SIDEBAR_WIDTH_KEY;
+    private readonly LEFT_SIDEBAR_WIDTH_KEY;
+    constructor(dialogRef: MatDialogRef<UiFormBuilderEditorComponent>, dialogData: UiEditorDialogData);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Aggiunge una nuova sezione. */
+    onAddSection(): void;
+    /** Salva nel localStorage. */
+    onSave(): void;
+    /** Crea un nuovo form. */
+    onNewForm(): void;
+    /** Importa da file JSON. */
+    onImportJson(): void;
+    /** Esporta come file JSON. */
+    onExportJson(): void;
+    /** Pulisce tutto lo schema. */
+    onClear(): void;
+    onSectionDuplicate(sectionId: string): void;
+    onSectionDelete(sectionId: string): void;
+    onFieldSelect(sectionId: string, fieldKey: string): void;
+    onFieldDuplicate(sectionId: string, fieldKey: string): void;
+    onFieldDelete(sectionId: string, fieldKey: string): void;
+    onFieldUpdate(sectionId: string, fieldKey: string, updates: Partial<UiFormFieldDescriptor>): void;
+    /** Gestisce il drop di un campo (dalla palette o tra sezioni). */
+    onFieldDrop(event: CdkDragDrop<any>): void;
+    /** Campo attualmente selezionato. */
+    get selectedField(): UiFormFieldDescriptor | null;
+    /** ID della sezione del campo selezionato. */
+    get selectedFieldSectionId(): string | null;
+    onTabChange(index: number): void;
+    refreshPreview(): void;
+    /** Chiude la modale restituendo lo schema corrente. */
+    closeDialog(): void;
+    onResizeStart(event: MouseEvent): void;
+    private onResizeMove;
+    private onResizeEnd;
+    onLeftResizeStart(event: MouseEvent): void;
+    private onLeftResizeMove;
+    private onLeftResizeEnd;
+    private checkForRecovery;
+    private autoSave;
+    private updateBreadcrumb;
+    private updateAvailableFields;
+    private showMessage;
+    private loadSidebarWidth;
+    private saveSidebarWidth;
+    private saveLeftSidebarWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormBuilderEditorComponent, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormBuilderEditorComponent, "ui-form-builder-editor", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,38 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { UiFormSchema } from '../form-builder/types/index';
+import { UiFormBuilderEditorComponent } from './form-builder-editor.component';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per aprire l'editor visuale del form builder
+ * in una modale fullscreen tramite il UiModalService.
+ *
+ * @usageNotes
+ *
+ * ### Apertura base
+ * ```typescript
+ * const ref = this.editorService.open();
+ * ref.afterClosed().subscribe(schema => {
+ *   if (schema) console.log('Schema risultante:', schema);
+ * });
+ * ```
+ *
+ * ### Apertura con schema iniziale
+ * ```typescript
+ * this.editorService.open(myExistingSchema)
+ *   .afterClosed()
+ *   .subscribe(schema => { ... });
+ * ```
+ */
+export declare class UiFormBuilderEditorService {
+    /** @internal Servizio modale per l'apertura. */
+    private readonly modalService;
+    /**
+     * Apre l'editor in una modale fullscreen.
+     *
+     * @param initialSchema - Schema iniziale da caricare nell'editor
+     * @returns Riferimento alla dialog per gestire chiusura e risultato
+     */
+    open(initialSchema?: UiFormSchema): MatDialogRef<UiFormBuilderEditorComponent, UiFormSchema | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormBuilderEditorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiFormBuilderEditorService>;
+}

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

@@ -0,0 +1,15 @@
+export { UiFormBuilderEditorComponent } from './form-builder-editor.component';
+export { UiFormBuilderEditorService } from './form-builder-editor.service';
+export { UiEditorStateService } from './services/editor-state.service';
+export { UiEditorPersistenceService } from './services/editor-persistence.service';
+export { UiEditorFieldFactoryService } from './services/field-factory.service';
+export { UiEditorToolbarComponent } from './sub-components/editor-toolbar/editor-toolbar.component';
+export { UiFieldPaletteComponent } from './sub-components/field-palette/field-palette.component';
+export { UiSectionEditorComponent } from './sub-components/section-editor/section-editor.component';
+export { UiEditorFieldConfigPanelComponent } from './sub-components/field-config-panel/field-config-panel.component';
+export { UiEditorPreviewContainerComponent } from './sub-components/preview-container/preview-container.component';
+export { UiValidationEditorComponent } from './sub-components/validation-editor/validation-editor.component';
+export { UiConditionEditorComponent } from './sub-components/condition-editor/condition-editor.component';
+export { UiOptionsEditorComponent } from './sub-components/options-editor/options-editor.component';
+export { UiEditorFormValuesPanelComponent } from './sub-components/form-values-panel/form-values-panel.component';
+export * from './types/editor.types';

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

@@ -0,0 +1,42 @@
+import { UiFormSchema } from '../../form-builder/types/index';
+import * as i0 from "@angular/core";
+/**
+ * Gestisce il salvataggio e il recupero degli schemi dell'editor.
+ *
+ * Supporta:
+ * - Auto-save e recupero da localStorage
+ * - Import/export da/verso file JSON
+ * - Backup automatici con rotazione (max 5)
+ */
+export declare class UiEditorPersistenceService {
+    /** @internal Chiave localStorage per l'auto-save. */
+    private readonly STORAGE_KEY;
+    /** @internal Versione dello storage per migrazioni future. */
+    private readonly STORAGE_VERSION;
+    /** @internal Durata massima di un salvataggio (24 ore). */
+    private readonly MAX_AGE_MS;
+    /** Salva lo schema nel localStorage. */
+    saveToLocalStorage(schema: UiFormSchema): void;
+    /** Carica lo schema dal localStorage (null se scaduto o assente). */
+    loadFromLocalStorage(): UiFormSchema | null;
+    /** Verifica se esiste un salvataggio valido. */
+    hasLocalStorageData(): boolean;
+    /** Restituisce la data dell'ultimo salvataggio. */
+    getLocalStorageAge(): Date | null;
+    /** Rimuove il salvataggio dal localStorage. */
+    clearLocalStorage(): void;
+    /** Esporta lo schema come file JSON scaricabile. */
+    exportToJSON(schema: UiFormSchema, filename?: string): void;
+    /** Importa lo schema da un file JSON. */
+    importFromJSON(file: File): Promise<UiFormSchema>;
+    /** Crea un backup dello schema prima di operazioni distruttive. */
+    createBackup(schema: UiFormSchema): void;
+    /** @internal Validazione strutturale minima dello schema. */
+    private isValidSchema;
+    /** @internal Scarica un blob come file. */
+    private downloadBlob;
+    /** @internal Mantiene solo gli ultimi 5 backup. */
+    private cleanOldBackups;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiEditorPersistenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiEditorPersistenceService>;
+}

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

@@ -0,0 +1,66 @@
+import { Observable } from 'rxjs';
+import { UiFormSchema, UiFormSection, UiFormFieldDescriptor } from '../../form-builder/types/index';
+import { UiEditorState, UiEditorSchemaValidationResult } from '../types/editor.types';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la gestione reattiva dello stato dell'editor visuale.
+ *
+ * Espone lo stato come Observable e fornisce metodi immutabili
+ * per tutte le operazioni CRUD su sezioni e campi.
+ */
+export declare class UiEditorStateService {
+    /** @internal Factory per la creazione dei campi. */
+    private readonly fieldFactory;
+    /** @internal Stato iniziale dell'editor. */
+    private readonly initialState;
+    /** @internal Subject per lo stato dell'editor. */
+    private readonly _state$;
+    /** Stream reattivo dello stato dell'editor. */
+    readonly state$: Observable<UiEditorState>;
+    /** Restituisce un snapshot dello stato corrente. */
+    getCurrentState(): UiEditorState;
+    /** Restituisce lo schema corrente. */
+    getSchema(): UiFormSchema;
+    /** @internal Aggiorna lo stato e marca come dirty. */
+    private updateState;
+    /** Imposta uno schema completo (es. da import). */
+    setSchema(schema: UiFormSchema): void;
+    /** Marca lo stato come salvato. */
+    markAsSaved(): void;
+    /** Reset allo stato iniziale. */
+    reset(): void;
+    /** Pulisce lo schema mantenendo l'ID. */
+    clearSchema(): void;
+    /** Aggiunge una nuova sezione e la seleziona. */
+    addSection(section?: Partial<UiFormSection>): string;
+    /** Rimuove una sezione per ID. */
+    removeSection(sectionId: string): void;
+    /** Aggiorna proprieta di una sezione. */
+    updateSection(sectionId: string, updates: Partial<UiFormSection>): void;
+    /** Duplica una sezione con nuovi ID per sezione e campi. */
+    duplicateSection(sectionId: string): string | null;
+    /** Aggiunge un campo a una sezione in una posizione specifica. */
+    addFieldAtIndex(sectionId: string, field: UiFormFieldDescriptor, index: number): void;
+    /** Rimuove un campo da una sezione. */
+    removeField(sectionId: string, fieldKey: string): void;
+    /** Aggiorna proprieta di un campo. */
+    updateField(sectionId: string, fieldKey: string, fieldUpdates: Partial<UiFormFieldDescriptor>): void;
+    /** Duplica un campo nella stessa sezione. */
+    duplicateField(sectionId: string, fieldKey: string): void;
+    /** Riordina un campo all'interno della stessa sezione. */
+    moveFieldInSection(sectionId: string, fromIndex: number, toIndex: number): void;
+    /** Sposta un campo tra due sezioni diverse. */
+    moveFieldBetweenSections(fromSectionId: string, toSectionId: string, fieldKey: string, toIndex: number): void;
+    /** Seleziona una sezione (deseleziona il campo). */
+    selectSection(sectionId: string | null): void;
+    /** Seleziona un campo (e la sua sezione). */
+    selectField(sectionId: string, fieldKey: string | null): void;
+    /** Trova la sezione che contiene un campo. */
+    findSectionByFieldKey(fieldKey: string): UiFormSection | null;
+    /** Trova un campo per chiave attraverso tutte le sezioni. */
+    findFieldByKey(fieldKey: string): UiFormFieldDescriptor | null;
+    /** Valida lo schema corrente cercando errori e warning strutturali. */
+    validateSchema(): UiEditorSchemaValidationResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiEditorStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiEditorStateService>;
+}

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

@@ -0,0 +1,28 @@
+import { UiFormFieldDescriptor, UiFieldType } from '../../form-builder/types/index';
+import * as i0 from "@angular/core";
+/**
+ * Servizio factory per creare field descriptor con configurazioni
+ * di default appropriate per ogni tipo di campo.
+ */
+export declare class UiEditorFieldFactoryService {
+    /** @internal Contatore per generare chiavi univoche. */
+    private fieldCounter;
+    /**
+     * Crea un field descriptor di default per il tipo specificato.
+     *
+     * @param type - Tipo di campo da creare
+     * @param key - Chiave opzionale (se omessa viene generata automaticamente)
+     * @returns Field descriptor con valori di default
+     */
+    createDefaultField(type: UiFieldType, key?: string): UiFormFieldDescriptor;
+    /** Duplica un campo generando una nuova chiave univoca. */
+    duplicateField(field: UiFormFieldDescriptor): UiFormFieldDescriptor;
+    /** @internal Genera una chiave univoca per un campo. */
+    private generateUniqueKey;
+    /** @internal Mappa tipo -> label di default. */
+    private getDefaultLabel;
+    /** @internal Mappa tipo -> placeholder di default. */
+    private getDefaultPlaceholder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiEditorFieldFactoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiEditorFieldFactoryService>;
+}