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

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

@@ -0,0 +1,1064 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectorRef, ViewEncapsulation, ViewChild, inject, HostListener, } from '@angular/core';
+import { LucideAngularModule } from 'lucide-angular';
+import { Subject, takeUntil } from 'rxjs';
+import { UiButtonComponent } from '../../components/button/index';
+import { UiFormBuilderComponent } from './form-builder.component';
+import { UiWizardSyncService, } from './services/wizard-sync.service';
+import { UiLoggerService } from '../../core/logging/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "lucide-angular";
+// ─── Componenti interni ───────────────────────────────────────────
+/**
+ * Header del wizard: progresso e info dello step corrente.
+ * Con `progressStyle: 'steps'` emette `stepSelect` per saltare a uno step già completato.
+ */
+export class UiWizardHeaderComponent {
+    constructor() {
+        this.stepGroups = [];
+        this.progressPercent = 0;
+        this.currentStepTitle = '';
+        this.currentStepDescription = '';
+        /** Quando true, i bullet step non sono interattivi (es. wizard disabilitato). */
+        this.disableStepIndicators = false;
+        this.stepSelect = new EventEmitter();
+    }
+    /** Indice step selezionabile tramite bullet/titolo (solo step già completati, non il corrente). */
+    isStepIndicatorNavigable(stepIndex) {
+        if (this.config.allowStepIndicatorNavigation === false)
+            return false;
+        if (this.disableStepIndicators)
+            return false;
+        if (this.config.allowBackNavigation === false)
+            return false;
+        return (stepIndex !== this.state.currentStep &&
+            this.state.completedSteps.has(stepIndex));
+    }
+    /** Testo accessibile per il pulsante step (navigazione). */
+    stepAriaLabel(stepTitle) {
+        return `Vai allo step: ${stepTitle}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiWizardHeaderComponent, isStandalone: true, selector: "ui-wizard-header", inputs: { config: "config", stepGroups: "stepGroups", state: "state", progressPercent: "progressPercent", currentStepTitle: "currentStepTitle", currentStepDescription: "currentStepDescription", disableStepIndicators: "disableStepIndicators" }, outputs: { stepSelect: "stepSelect" }, ngImport: i0, template: `
+    <div class="ui-form-wizard__header">
+      @if (config.showProgress !== false) {
+        @if (config.progressStyle !== 'steps') {
+          <div class="ui-form-wizard__progress-bar">
+            <div
+              class="ui-form-wizard__progress-fill"
+              [style.width.%]="progressPercent"
+            ></div>
+          </div>
+          <span class="ui-form-wizard__progress-text">
+            {{ progressPercent }}% completato
+          </span>
+        } @else {
+          <div class="ui-form-wizard__steps">
+            @for (
+              group of stepGroups;
+              track $index;
+              let i = $index
+            ) {
+              <div
+                class="ui-form-wizard__step"
+                [class.ui-form-wizard__step--current]="
+                  i === state.currentStep
+                "
+                [class.ui-form-wizard__step--completed]="
+                  state.completedSteps.has(i)
+                "
+                [class.ui-form-wizard__step--visited]="
+                  state.visitedSteps.has(i)
+                "
+                [class.ui-form-wizard__step--navigable]="
+                  isStepIndicatorNavigable(i)
+                "
+              >
+                @if (isStepIndicatorNavigable(i)) {
+                  <button
+                    type="button"
+                    class="ui-form-wizard__step-trigger"
+                    [attr.aria-label]="
+                      stepAriaLabel(
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      )
+                    "
+                    (click)="stepSelect.emit(i)"
+                  >
+                    <div class="ui-form-wizard__step-circle">
+                      @if (state.completedSteps.has(i)) {
+                        <lucide-icon name="check" [size]="16" />
+                      } @else {
+                        <span>{{ i + 1 }}</span>
+                      }
+                    </div>
+                    <div class="ui-form-wizard__step-label">
+                      {{
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      }}
+                    </div>
+                  </button>
+                } @else {
+                  <div
+                    class="ui-form-wizard__step-static"
+                    [attr.aria-current]="
+                      i === state.currentStep ? 'step' : null
+                    "
+                  >
+                    <div class="ui-form-wizard__step-circle">
+                      @if (state.completedSteps.has(i)) {
+                        <lucide-icon name="check" [size]="16" />
+                      } @else {
+                        <span>{{ i + 1 }}</span>
+                      }
+                    </div>
+                    <div class="ui-form-wizard__step-label">
+                      {{
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      }}
+                    </div>
+                  </div>
+                }
+              </div>
+            }
+          </div>
+        }
+      }
+
+      <div class="ui-form-wizard__step-info">
+        <h2 class="ui-form-wizard__step-title">{{ currentStepTitle }}</h2>
+        @if (currentStepDescription) {
+          <p class="ui-form-wizard__step-description">
+            {{ currentStepDescription }}
+          </p>
+        }
+        <span class="ui-form-wizard__step-counter">
+          Passo {{ state.currentStep + 1 }} di {{ state.totalSteps }}
+        </span>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i1.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ui-wizard-header',
+                    standalone: true,
+                    imports: [LucideAngularModule],
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div class="ui-form-wizard__header">
+      @if (config.showProgress !== false) {
+        @if (config.progressStyle !== 'steps') {
+          <div class="ui-form-wizard__progress-bar">
+            <div
+              class="ui-form-wizard__progress-fill"
+              [style.width.%]="progressPercent"
+            ></div>
+          </div>
+          <span class="ui-form-wizard__progress-text">
+            {{ progressPercent }}% completato
+          </span>
+        } @else {
+          <div class="ui-form-wizard__steps">
+            @for (
+              group of stepGroups;
+              track $index;
+              let i = $index
+            ) {
+              <div
+                class="ui-form-wizard__step"
+                [class.ui-form-wizard__step--current]="
+                  i === state.currentStep
+                "
+                [class.ui-form-wizard__step--completed]="
+                  state.completedSteps.has(i)
+                "
+                [class.ui-form-wizard__step--visited]="
+                  state.visitedSteps.has(i)
+                "
+                [class.ui-form-wizard__step--navigable]="
+                  isStepIndicatorNavigable(i)
+                "
+              >
+                @if (isStepIndicatorNavigable(i)) {
+                  <button
+                    type="button"
+                    class="ui-form-wizard__step-trigger"
+                    [attr.aria-label]="
+                      stepAriaLabel(
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      )
+                    "
+                    (click)="stepSelect.emit(i)"
+                  >
+                    <div class="ui-form-wizard__step-circle">
+                      @if (state.completedSteps.has(i)) {
+                        <lucide-icon name="check" [size]="16" />
+                      } @else {
+                        <span>{{ i + 1 }}</span>
+                      }
+                    </div>
+                    <div class="ui-form-wizard__step-label">
+                      {{
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      }}
+                    </div>
+                  </button>
+                } @else {
+                  <div
+                    class="ui-form-wizard__step-static"
+                    [attr.aria-current]="
+                      i === state.currentStep ? 'step' : null
+                    "
+                  >
+                    <div class="ui-form-wizard__step-circle">
+                      @if (state.completedSteps.has(i)) {
+                        <lucide-icon name="check" [size]="16" />
+                      } @else {
+                        <span>{{ i + 1 }}</span>
+                      }
+                    </div>
+                    <div class="ui-form-wizard__step-label">
+                      {{
+                        group[0].wizardStep?.stepTitle ||
+                          group[0].title ||
+                          'Step ' + (i + 1)
+                      }}
+                    </div>
+                  </div>
+                }
+              </div>
+            }
+          </div>
+        }
+      }
+
+      <div class="ui-form-wizard__step-info">
+        <h2 class="ui-form-wizard__step-title">{{ currentStepTitle }}</h2>
+        @if (currentStepDescription) {
+          <p class="ui-form-wizard__step-description">
+            {{ currentStepDescription }}
+          </p>
+        }
+        <span class="ui-form-wizard__step-counter">
+          Passo {{ state.currentStep + 1 }} di {{ state.totalSteps }}
+        </span>
+      </div>
+    </div>
+  `,
+                }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], stepGroups: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], progressPercent: [{
+                type: Input
+            }], currentStepTitle: [{
+                type: Input
+            }], currentStepDescription: [{
+                type: Input
+            }], disableStepIndicators: [{
+                type: Input
+            }], stepSelect: [{
+                type: Output
+            }] } });
+/**
+ * Footer del wizard: pulsanti di navigazione e salvataggio.
+ * Emette eventi per Previous, Next, Finish, Save.
+ */
+export class UiWizardFooterComponent {
+    constructor() {
+        this.isLastStep = false;
+        this.previous = new EventEmitter();
+        this.next = new EventEmitter();
+        this.finish = new EventEmitter();
+        this.save = new EventEmitter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiWizardFooterComponent, isStandalone: true, selector: "ui-wizard-footer", inputs: { config: "config", state: "state", isLastStep: "isLastStep" }, outputs: { previous: "previous", next: "next", finish: "finish", save: "save" }, ngImport: i0, template: `
+    <div class="ui-form-wizard__footer">
+      @if (
+        config.allowBackNavigation !== false && state.currentStep > 0
+      ) {
+        <div class="ui-form-wizard__nav-action">
+          <ui-button
+            [label]="config.buttonLabels?.previous ?? 'Indietro'"
+            variant="outline"
+            icon="chevron-left"
+            (click)="previous.emit()"
+          />
+          <span class="ui-form-wizard__nav-hint">Ctrl + ←</span>
+        </div>
+      } @else {
+        <div></div>
+      }
+
+      <div class="ui-form-wizard__footer-right">
+        @if (config.autoSave && config.buttonLabels?.save) {
+          <ui-button
+            [label]="config.buttonLabels!.save!"
+            variant="outline"
+            (click)="save.emit()"
+          />
+        }
+        <div class="ui-form-wizard__nav-action">
+          @if (isLastStep) {
+            <ui-button
+              [label]="config.buttonLabels?.finish ?? 'Completa'"
+              variant="primary"
+              icon="check"
+              iconPosition="trailing"
+              (click)="finish.emit()"
+            />
+          } @else {
+            <ui-button
+              [label]="
+                config.buttonLabels?.next ??
+                  config.buttonLabels?.submit ??
+                  'Avanti'
+              "
+              variant="primary"
+              icon="chevron-right"
+              iconPosition="trailing"
+              (click)="next.emit()"
+            />
+          }
+          <span class="ui-form-wizard__nav-hint">Ctrl + →</span>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: UiButtonComponent, selector: "ui-button", inputs: ["label", "tooltip", "variant", "size", "icon", "iconPosition", "loading", "disabled", "fullWidth", "type", "ariaLabel", "customClass"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiWizardFooterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ui-wizard-footer',
+                    standalone: true,
+                    imports: [UiButtonComponent],
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div class="ui-form-wizard__footer">
+      @if (
+        config.allowBackNavigation !== false && state.currentStep > 0
+      ) {
+        <div class="ui-form-wizard__nav-action">
+          <ui-button
+            [label]="config.buttonLabels?.previous ?? 'Indietro'"
+            variant="outline"
+            icon="chevron-left"
+            (click)="previous.emit()"
+          />
+          <span class="ui-form-wizard__nav-hint">Ctrl + ←</span>
+        </div>
+      } @else {
+        <div></div>
+      }
+
+      <div class="ui-form-wizard__footer-right">
+        @if (config.autoSave && config.buttonLabels?.save) {
+          <ui-button
+            [label]="config.buttonLabels!.save!"
+            variant="outline"
+            (click)="save.emit()"
+          />
+        }
+        <div class="ui-form-wizard__nav-action">
+          @if (isLastStep) {
+            <ui-button
+              [label]="config.buttonLabels?.finish ?? 'Completa'"
+              variant="primary"
+              icon="check"
+              iconPosition="trailing"
+              (click)="finish.emit()"
+            />
+          } @else {
+            <ui-button
+              [label]="
+                config.buttonLabels?.next ??
+                  config.buttonLabels?.submit ??
+                  'Avanti'
+              "
+              variant="primary"
+              icon="chevron-right"
+              iconPosition="trailing"
+              (click)="next.emit()"
+            />
+          }
+          <span class="ui-form-wizard__nav-hint">Ctrl + →</span>
+        </div>
+      </div>
+    </div>
+  `,
+                }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], isLastStep: [{
+                type: Input
+            }], previous: [{
+                type: Output
+            }], next: [{
+                type: Output
+            }], finish: [{
+                type: Output
+            }], save: [{
+                type: Output
+            }] } });
+// ─── Componente wizard principale ─────────────────────────────────
+/**
+ * Componente wizard che wrappa `UiFormBuilderComponent`
+ * aggiungendo navigazione multi-step, barra di progresso,
+ * validazione per step e sincronizzazione wireless.
+ * Più sezioni schema con lo stesso `wizardStep.stepNumber` formano un unico passo
+ * (es. più blocchi collassabili per step); metadati del passo dalla prima sezione del gruppo.
+ *
+ * @selector ui-form-wizard
+ *
+ * @example
+ * ```html
+ * <ui-form-wizard
+ *   [schema]="wizardSchema"
+ *   [wizardConfig]="wizardConfig"
+ *   (wizardComplete)="onComplete($event)"
+ *   (stepChange)="onStepChange($event)"
+ * />
+ * ```
+ */
+export class UiFormWizardComponent {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.wizardSync = inject(UiWizardSyncService);
+        this.logger = inject(UiLoggerService, { optional: true });
+        this.destroy$ = new Subject();
+        /** Metodi di validazione custom per step. */
+        this.customValidationMethods = {};
+        /** Dati iniziali. */
+        this.initialData = {};
+        /** Modalita sola lettura. */
+        this.readonly = false;
+        /** Stato disabilitato. */
+        this.disabled = false;
+        /** Pulsante in caricamento. */
+        this.loadingFor = null;
+        /** Template per campi `type: 'custom'` (inoltro al form builder). */
+        this.customFieldTemplates = {};
+        // ─── Output ─────────────────────────────────────────────────────
+        this.stepChange = new EventEmitter();
+        this.stepComplete = new EventEmitter();
+        this.stepValidationFailed = new EventEmitter();
+        this.wizardComplete = new EventEmitter();
+        this.valueChange = new EventEmitter();
+        this.validationChange = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        // ─── Stato ──────────────────────────────────────────────────────
+        this.state = {
+            currentStep: 0,
+            totalSteps: 0,
+            completedSteps: new Set(),
+            visitedSteps: new Set([0]),
+            isValid: false,
+            stepErrors: {},
+        };
+        /**
+         * Gruppi di sezioni schema per passo logico del wizard.
+         * Sezioni con lo stesso `wizardStep.stepNumber` compongono un unico passo (ordine: come in `schema.sections` dopo sort per numero).
+         */
+        this.wizardStepGroups = [];
+        /** Dati accumulati del form. */
+        this.accumulatedData = {};
+        /**
+         * Schema cachato per lo step corrente.
+         * Evita di creare un nuovo oggetto ad ogni ciclo di change detection,
+         * cosa che causerebbe rebuild infiniti nel form builder.
+         */
+        this._cachedStepSchema = null;
+        this._cachedStepIndex = -1;
+    }
+    // ─── Getter calcolati ───────────────────────────────────────────
+    get currentStepSchema() {
+        // Se lo step non e cambiato, restituisci lo schema cachato
+        if (this._cachedStepIndex === this.state.currentStep &&
+            this._cachedStepSchema) {
+            return this._cachedStepSchema;
+        }
+        const group = this.wizardStepGroups[this.state.currentStep];
+        if (!group?.length)
+            return null;
+        this._cachedStepSchema = {
+            id: this.schema.id + '-step-' + this.state.currentStep,
+            sections: group,
+            config: { ...this.schema.config, hideFooter: true, showButtons: false },
+        };
+        this._cachedStepIndex = this.state.currentStep;
+        return this._cachedStepSchema;
+    }
+    get currentStepTitle() {
+        const primary = this.wizardStepGroups[this.state.currentStep]?.[0];
+        return primary?.wizardStep?.stepTitle || primary?.title || '';
+    }
+    get currentStepDescription() {
+        const primary = this.wizardStepGroups[this.state.currentStep]?.[0];
+        return primary?.wizardStep?.stepDescription || primary?.description || '';
+    }
+    get isLastStep() {
+        return this.state.currentStep >= this.state.totalSteps - 1;
+    }
+    get progressPercent() {
+        if (this.state.totalSteps <= 1)
+            return 100;
+        return Math.round((this.state.currentStep / (this.state.totalSteps - 1)) * 100);
+    }
+    /**
+     * Dati passati al form builder: unione tra valori forniti dal consumer e
+     * stato accumulato tra gli step. Senza questo, tornando indietro il builder
+     * riceverebbe solo `initialData` e ricreerebbe i campi vuoti, pur avendo
+     * i valori ancora in `accumulatedData`.
+     */
+    get mergedInitialDataForBuilder() {
+        return { ...this.initialData, ...this.accumulatedData };
+    }
+    /** Mostra la navigazione sopra il form builder. */
+    get showTopNav() {
+        if (this.wizardConfig.showNavigationButtons === false)
+            return false;
+        const pos = this.wizardConfig.navigationPosition;
+        return pos === 'top' || pos === 'both';
+    }
+    /** Mostra la navigazione sotto il form builder. */
+    get showBottomNav() {
+        if (this.wizardConfig.showNavigationButtons === false)
+            return false;
+        const pos = this.wizardConfig.navigationPosition;
+        return pos === 'bottom' || pos === 'both' || pos == null;
+    }
+    // ─── Lifecycle ──────────────────────────────────────────────────
+    ngOnInit() {
+        if (!this.schema) {
+            this.logger?.logWizardAction('init', { wizardId: this.wizardConfig?.wizardId, error: 'schema non presente' });
+            return;
+        }
+        this.wizardStepGroups = this.buildWizardStepGroups(this.schema.sections);
+        this.state.totalSteps = this.wizardStepGroups.length;
+        this.accumulatedData = { ...this.initialData };
+        this.logger?.logWizardAction('init', {
+            wizardId: this.wizardConfig?.wizardId,
+            schemaId: this.schema.id,
+            totalSteps: this.state.totalSteps,
+            totalSections: this.wizardStepGroups.reduce((sum, g) => sum + g.length, 0),
+        });
+        // Sincronizzazione wireless
+        if (this.wizardConfig.wizardId) {
+            this.syncWizardState();
+            // Ascolta navigazione esterna
+            this.wizardSync
+                .getWizardState$(this.wizardConfig.wizardId)
+                .pipe(takeUntil(this.destroy$))
+                .subscribe((data) => {
+                if (data && data.wizardState.currentStep !== this.state.currentStep) {
+                    this.navigateToStep(data.wizardState.currentStep);
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.logger?.logWizardAction('destroy', {
+            wizardId: this.wizardConfig?.wizardId,
+            schemaId: this.schema?.id,
+            currentStep: this.state.currentStep,
+        });
+        this.destroy$.next();
+        this.destroy$.complete();
+        if (this.wizardConfig?.wizardId) {
+            this.wizardSync.unregisterWizard(this.wizardConfig.wizardId);
+        }
+    }
+    /**
+     * Scorciatoia: Ctrl + Freccia sinistra/destra per navigare come i pulsanti
+     * Indietro / Avanti (sull'ultimo step, Avanti equivale a Completa).
+     * Ignorata se il focus è in un campo di input per non interferire con la digitazione.
+     */
+    onDocumentKeydown(event) {
+        if (!this.schema || !this.wizardConfig || this.disabled)
+            return;
+        if (this.wizardConfig.showNavigationButtons === false)
+            return;
+        if (!event.ctrlKey || event.altKey || event.metaKey || event.shiftKey)
+            return;
+        if (event.key !== 'ArrowLeft' && event.key !== 'ArrowRight')
+            return;
+        if (this.isEditableKeyboardTarget(event.target))
+            return;
+        if (event.key === 'ArrowLeft') {
+            if (this.wizardConfig.allowBackNavigation === false)
+                return;
+            if (this.state.currentStep <= 0)
+                return;
+            event.preventDefault();
+            this.logger?.logWizardAction('keyboardNavigation', {
+                wizardId: this.wizardConfig.wizardId,
+                direction: 'previous',
+                fromStep: this.state.currentStep,
+            });
+            this.goToPreviousStep();
+            return;
+        }
+        // ArrowRight
+        event.preventDefault();
+        this.logger?.logWizardAction('keyboardNavigation', {
+            wizardId: this.wizardConfig.wizardId,
+            direction: this.isLastStep ? 'finish' : 'next',
+            fromStep: this.state.currentStep,
+        });
+        if (this.isLastStep) {
+            void this.finishWizard();
+        }
+        else {
+            void this.goToNextStep();
+        }
+    }
+    /** True se il target del keydown è un elemento dove la digitazione ha priorità sulla shortcut wizard. */
+    isEditableKeyboardTarget(target) {
+        if (!target || !(target instanceof HTMLElement))
+            return false;
+        const el = target;
+        if (el.isContentEditable)
+            return true;
+        const tag = el.tagName;
+        if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT')
+            return true;
+        return false;
+    }
+    // ─── Navigazione ────────────────────────────────────────────────
+    /** Vai allo step successivo con validazione. */
+    async goToNextStep() {
+        if (this.isLastStep)
+            return;
+        // Valida step corrente
+        if (!(await this.validateCurrentStep()))
+            return;
+        // Salva dati step corrente
+        this.state.completedSteps.add(this.state.currentStep);
+        await this.autoSaveIfNeeded();
+        this.navigateToStep(this.state.currentStep + 1);
+    }
+    /** Torna allo step precedente. */
+    goToPreviousStep() {
+        if (this.state.currentStep <= 0)
+            return;
+        this.navigateToStep(this.state.currentStep - 1);
+    }
+    /**
+     * Navigazione tramite indicatori step (bullet + titolo) quando `progressStyle` è `'steps'`.
+     * Consentito solo verso step già marcati completati.
+     */
+    onWizardStepIndicatorSelect(stepIndex) {
+        if (this.disabled)
+            return;
+        if (this.wizardConfig.allowStepIndicatorNavigation === false)
+            return;
+        if (this.wizardConfig.allowBackNavigation === false)
+            return;
+        if (stepIndex === this.state.currentStep)
+            return;
+        if (!this.state.completedSteps.has(stepIndex))
+            return;
+        this.logger?.logWizardAction('navigation', {
+            wizardId: this.wizardConfig.wizardId,
+            via: 'stepIndicator',
+            fromStep: this.state.currentStep,
+            toStep: stepIndex,
+        });
+        this.navigateToStep(stepIndex);
+    }
+    /** Completa il wizard. */
+    async finishWizard() {
+        if (!(await this.validateCurrentStep())) {
+            this.logger?.logWizardAction('stepValidationFailed', {
+                wizardId: this.wizardConfig.wizardId,
+                step: this.state.currentStep,
+                context: 'finish',
+            });
+            return;
+        }
+        this.state.completedSteps.add(this.state.currentStep);
+        await this.autoSaveIfNeeded();
+        this.logger?.logWizardAction('complete', {
+            wizardId: this.wizardConfig.wizardId,
+            schemaId: this.schema?.id,
+            totalSteps: this.state.totalSteps,
+            completedSteps: Array.from(this.state.completedSteps),
+        });
+        this.wizardComplete.emit(this.accumulatedData);
+    }
+    /** Salva lo step corrente manualmente. */
+    async saveCurrentStep() {
+        if (this.wizardConfig.onStepSave) {
+            const data = this.formBuilder?.getFormValue() || {};
+            this.logger?.logWizardAction('save', {
+                wizardId: this.wizardConfig.wizardId,
+                step: this.state.currentStep,
+                schemaId: this.schema?.id,
+            });
+            await this.wizardConfig.onStepSave(data, this.state.currentStep);
+        }
+    }
+    // ─── Callback form builder ─────────────────────────────────────
+    onValueChange(data) {
+        this.accumulatedData = { ...this.accumulatedData, ...data };
+        this.logger?.logWizardAction('valueChange', {
+            wizardId: this.wizardConfig.wizardId,
+            step: this.state.currentStep,
+            schemaId: this.schema?.id,
+            changedKeys: Object.keys(data),
+        });
+        this.valueChange.emit(this.accumulatedData);
+    }
+    onValidationChange(state) {
+        this.state.isValid = state.valid;
+        this.validationChange.emit(state);
+    }
+    // ─── Navigazione interna ───────────────────────────────────────
+    navigateToStep(targetStep) {
+        if (targetStep < 0 || targetStep >= this.state.totalSteps)
+            return;
+        const from = this.state.currentStep;
+        this.state.currentStep = targetStep;
+        this.state.visitedSteps.add(targetStep);
+        // Invalida la cache per forzare la creazione di un nuovo schema
+        this._cachedStepSchema = null;
+        this._cachedStepIndex = -1;
+        this.logger?.logWizardAction('stepChange', {
+            wizardId: this.wizardConfig.wizardId,
+            from,
+            to: targetStep,
+            direction: targetStep > from ? 'next' : 'previous',
+            schemaId: this.schema?.id,
+        });
+        this.stepChange.emit({
+            from,
+            to: targetStep,
+            direction: targetStep > from ? 'next' : 'previous',
+        });
+        this.syncWizardState();
+        this.cdr.markForCheck();
+    }
+    async validateCurrentStep() {
+        this.formBuilder?.validateAllFields();
+        const group = this.wizardStepGroups[this.state.currentStep];
+        const primary = group?.[0];
+        const validateCustomComponents = primary?.wizardStep?.validation?.validateCustomComponents !== false;
+        const customFieldKeys = new Set(this.getCustomFieldKeysForGroup(group));
+        const isFormValid = validateCustomComponents
+            ? (this.formBuilder?.isFormValid() ?? true)
+            : (this.formBuilder?.isFormValidExcludingFieldKeys(customFieldKeys) ??
+                true);
+        const customFnName = primary?.wizardStep?.customValidationFn;
+        if (customFnName && this.customValidationMethods[customFnName]) {
+            const customValid = await this.customValidationMethods[customFnName](this.accumulatedData, this.state.currentStep, isFormValid);
+            if (!customValid) {
+                this.stepValidationFailed.emit({
+                    step: this.state.currentStep,
+                    errors: ['Validazione custom fallita'],
+                });
+                return false;
+            }
+        }
+        if (!isFormValid && primary?.wizardStep?.validation?.required !== false) {
+            let details = this.formBuilder?.getDetailedFormErrors() || [];
+            if (!validateCustomComponents && group?.length) {
+                details = this.filterErrorDetailsExcludingCustomFields(details, group, customFieldKeys);
+            }
+            const errors = details.flatMap((e) => e.errors);
+            this.logger?.logWizardAction('stepValidationFailed', {
+                wizardId: this.wizardConfig.wizardId,
+                step: this.state.currentStep,
+                errors,
+            });
+            this.stepValidationFailed.emit({
+                step: this.state.currentStep,
+                errors,
+            });
+            return false;
+        }
+        this.logger?.logWizardAction('stepComplete', {
+            wizardId: this.wizardConfig.wizardId,
+            step: this.state.currentStep,
+            schemaId: this.schema?.id,
+        });
+        this.stepComplete.emit({
+            step: this.state.currentStep,
+            data: this.formBuilder?.getFormValue() || {},
+        });
+        return true;
+    }
+    /**
+     * Raggruppa le sezioni con `wizardStep` per `stepNumber` (ordine stabile per numero, poi ordine di apparizione nello schema).
+     */
+    buildWizardStepGroups(sections) {
+        const withWizard = sections.filter((s) => s.wizardStep);
+        withWizard.sort((a, b) => (a.wizardStep.stepNumber || 0) - (b.wizardStep.stepNumber || 0));
+        const groups = [];
+        for (const s of withWizard) {
+            const num = s.wizardStep.stepNumber;
+            const prev = groups[groups.length - 1];
+            if (prev?.length &&
+                (prev[0].wizardStep.stepNumber || 0) === (num || 0)) {
+                prev.push(s);
+            }
+            else {
+                groups.push([s]);
+            }
+        }
+        return groups;
+    }
+    /** Chiavi dei campi `custom` in tutte le sezioni del passo corrente. */
+    getCustomFieldKeysForGroup(group) {
+        if (!group?.length)
+            return [];
+        const keys = [];
+        for (const section of group) {
+            for (const f of section.fields || []) {
+                if (f.type === 'custom')
+                    keys.push(f.key);
+            }
+        }
+        return keys;
+    }
+    /** Rimuove dagli errori i campi custom quando `validateCustomComponents` è false. */
+    filterErrorDetailsExcludingCustomFields(details, group, customKeys) {
+        const sectionIds = group.map((s) => s.id);
+        return details.filter((d) => {
+            const logicalKey = this.logicalFieldKeyFromDetailKeyForGroup(d.fieldKey, sectionIds);
+            return !customKeys.has(logicalKey);
+        });
+    }
+    /**
+     * Risolve la chiave logica del campo rispetto a tutte le sezioni del gruppo (campi flat o repeatable).
+     */
+    logicalFieldKeyFromDetailKeyForGroup(fieldKey, sectionIds) {
+        for (const id of sectionIds) {
+            const k = this.logicalFieldKeyFromDetailKey(fieldKey, id);
+            if (k !== fieldKey)
+                return k;
+        }
+        return fieldKey;
+    }
+    /** Estrae la chiave campo da `fieldKey` flat o `sectionId[i].fieldKey`. */
+    logicalFieldKeyFromDetailKey(fieldKey, sectionId) {
+        const re = new RegExp(`^${this.escapeRegExp(sectionId)}\\[\\d+\\]\\.(.+)$`);
+        const m = fieldKey.match(re);
+        return m ? m[1] : fieldKey;
+    }
+    escapeRegExp(s) {
+        return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    async autoSaveIfNeeded() {
+        if (this.wizardConfig.autoSave && this.wizardConfig.onStepSave) {
+            const data = this.formBuilder?.getFormValue() || {};
+            await this.wizardConfig.onStepSave(data, this.state.currentStep);
+        }
+    }
+    syncWizardState() {
+        if (!this.wizardConfig.wizardId)
+            return;
+        const syncData = {
+            wizardId: this.wizardConfig.wizardId,
+            wizardState: { ...this.state },
+            wizardSteps: this.wizardStepGroups.map((g) => ({
+                title: g[0]?.wizardStep?.stepTitle || g[0]?.title,
+                description: g[0]?.wizardStep?.stepDescription || g[0]?.description,
+            })),
+            isWizardMode: true,
+            schema: this.schema,
+        };
+        this.wizardSync.registerWizard(this.wizardConfig.wizardId, syncData);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormWizardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiFormWizardComponent, isStandalone: true, selector: "ui-form-wizard", inputs: { schema: "schema", wizardConfig: "wizardConfig", customValidationMethods: "customValidationMethods", initialData: "initialData", readonly: "readonly", disabled: "disabled", loadingFor: "loadingFor", customFieldTemplates: "customFieldTemplates", customFieldTemplateFallback: "customFieldTemplateFallback" }, outputs: { stepChange: "stepChange", stepComplete: "stepComplete", stepValidationFailed: "stepValidationFailed", wizardComplete: "wizardComplete", valueChange: "valueChange", validationChange: "validationChange", customEvent: "customEvent" }, host: { listeners: { "document:keydown": "onDocumentKeydown($event)" } }, viewQueries: [{ propertyName: "formBuilder", first: true, predicate: UiFormBuilderComponent, descendants: true }], ngImport: i0, template: `
+    @if (schema && wizardConfig) {
+      <div class="ui-form-wizard">
+        <!-- Header wizard (nascosto se wireless) -->
+        @if (!wizardConfig.wirelessHeading) {
+          <ui-wizard-header
+            [config]="wizardConfig"
+            [stepGroups]="wizardStepGroups"
+            [state]="state"
+            [progressPercent]="progressPercent"
+            [currentStepTitle]="currentStepTitle"
+            [currentStepDescription]="currentStepDescription"
+            [disableStepIndicators]="disabled"
+            (stepSelect)="onWizardStepIndicatorSelect($event)"
+          />
+        }
+
+        <!-- Navigazione sopra il form -->
+        @if (showTopNav) {
+          <ui-wizard-footer
+            class="ui-form-wizard__footer ui-form-wizard__footer--top"
+            [config]="wizardConfig"
+            [state]="state"
+            [isLastStep]="isLastStep"
+            (previous)="goToPreviousStep()"
+            (next)="goToNextStep()"
+            (finish)="finishWizard()"
+            (save)="saveCurrentStep()"
+          />
+        }
+
+        <div class="ui-form-wizard__content">
+          <!-- Form builder per lo step corrente -->
+          <ui-form-builder
+            [schema]="currentStepSchema!"
+            [initialData]="mergedInitialDataForBuilder"
+            [readonly]="readonly"
+            [disabled]="disabled"
+            [loadingFor]="loadingFor"
+            [customFieldTemplates]="customFieldTemplates"
+            [customFieldTemplateFallback]="customFieldTemplateFallback"
+            (valueChange)="onValueChange($event)"
+            (validationChange)="onValidationChange($event)"
+            (customEvent)="customEvent.emit($event)"
+          />
+        </div>
+
+        <!-- Navigazione sotto il form -->
+        @if (showBottomNav) {
+          <ui-wizard-footer
+            class="ui-form-wizard__footer"
+            [config]="wizardConfig"
+            [state]="state"
+            [isLastStep]="isLastStep"
+            (previous)="goToPreviousStep()"
+            (next)="goToNextStep()"
+            (finish)="finishWizard()"
+            (save)="saveCurrentStep()"
+          />
+        }
+      </div>
+    }
+  `, isInline: true, styles: [".ui-form-wizard{display:flex;flex-direction:column;gap:var(--ui-spacing-6);font-family:var(--ui-font-family)}.ui-form-wizard__header{display:flex;flex-direction:column;gap:var(--ui-spacing-4);padding-bottom:var(--ui-spacing-4);border-bottom:1px solid var(--ui-color-border)}.ui-form-wizard__progress-bar{height:6px;background:var(--ui-color-bg-subtle);border-radius:var(--ui-radius-full);overflow:hidden}.ui-form-wizard__progress-fill{height:100%;background:var(--ui-color-primary);border-radius:var(--ui-radius-full);transition:width var(--ui-transition-normal)}.ui-form-wizard__progress-text{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);margin-top:var(--ui-spacing-1)}.ui-form-wizard__steps{display:flex;justify-content:space-between;align-items:flex-start;gap:var(--ui-spacing-2);position:relative}.ui-form-wizard__steps:before{content:\"\";position:absolute;top:16px;left:24px;right:24px;height:2px;background:var(--ui-color-border);z-index:0}.ui-form-wizard__step{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1);z-index:1;flex:1}.ui-form-wizard__step-trigger,.ui-form-wizard__step-static{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1);width:100%;margin:0;padding:0;border:none;background:transparent;font:inherit;color:inherit;text-align:center}.ui-form-wizard__step-trigger{cursor:pointer;border-radius:var(--ui-radius-md);transition:background-color var(--ui-transition-fast)}.ui-form-wizard__step-trigger:hover{background-color:var(--ui-color-bg-subtle)}.ui-form-wizard__step-trigger:focus-visible{outline:2px solid var(--ui-color-primary);outline-offset:2px}.ui-form-wizard__step-static{cursor:default}.ui-form-wizard__step--navigable:not(.ui-form-wizard__step--current) .ui-form-wizard__step-trigger:hover .ui-form-wizard__step-label{color:var(--ui-color-primary)}.ui-form-wizard__step-circle{width:32px;height:32px;border-radius:var(--ui-radius-full);display:flex;align-items:center;justify-content:center;border:2px solid var(--ui-color-border);background:var(--ui-color-surface);font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text-muted);transition:background-color var(--ui-transition-fast),border-color var(--ui-transition-fast),color var(--ui-transition-fast)}.ui-form-wizard__step--current .ui-form-wizard__step-circle{border-color:var(--ui-color-primary);background:var(--ui-color-primary);color:#fff}.ui-form-wizard__step--completed .ui-form-wizard__step-circle{border-color:var(--ui-color-success, #16a34a);background:var(--ui-color-success, #16a34a);color:#fff}.ui-form-wizard__step--visited:not(.ui-form-wizard__step--current):not(.ui-form-wizard__step--completed) .ui-form-wizard__step-circle{border-color:var(--ui-color-primary);color:var(--ui-color-primary)}.ui-form-wizard__step-label{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);text-align:center;max-width:100px;line-height:1.3}.ui-form-wizard__step--current .ui-form-wizard__step-label{color:var(--ui-color-primary);font-weight:var(--ui-font-weight-semibold)}.ui-form-wizard__step-info{text-align:center}.ui-form-wizard__step-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-wizard__step-description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0 0 var(--ui-spacing-1)}.ui-form-wizard__step-counter{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted)}.ui-form-wizard__footer{display:flex;justify-content:space-between;align-items:center;width:100%}.ui-form-wizard__footer--top{padding-top:0;padding-bottom:var(--ui-spacing-4);border-top:none;border-bottom:1px solid var(--ui-color-border)}.ui-form-wizard__footer-right{display:flex;gap:var(--ui-spacing-3)}.ui-form-wizard__nav-action{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1)}.ui-form-wizard__nav-hint{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);line-height:1}\n"], dependencies: [{ kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: UiFormBuilderComponent, selector: "ui-form-builder", inputs: ["schema", "initialData", "readonly", "disabled", "buttonsOverride", "loadingFor", "customFieldTemplates", "customFieldTemplateFallback"], outputs: ["valueChange", "validationChange", "formSubmit", "formReset", "customEvent"] }, { kind: "component", type: UiWizardHeaderComponent, selector: "ui-wizard-header", inputs: ["config", "stepGroups", "state", "progressPercent", "currentStepTitle", "currentStepDescription", "disableStepIndicators"], outputs: ["stepSelect"] }, { kind: "component", type: UiWizardFooterComponent, selector: "ui-wizard-footer", inputs: ["config", "state", "isLastStep"], outputs: ["previous", "next", "finish", "save"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormWizardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-form-wizard', standalone: true, imports: [
+                        LucideAngularModule,
+                        UiButtonComponent,
+                        UiFormBuilderComponent,
+                        UiWizardHeaderComponent,
+                        UiWizardFooterComponent,
+                    ], encapsulation: ViewEncapsulation.None, template: `
+    @if (schema && wizardConfig) {
+      <div class="ui-form-wizard">
+        <!-- Header wizard (nascosto se wireless) -->
+        @if (!wizardConfig.wirelessHeading) {
+          <ui-wizard-header
+            [config]="wizardConfig"
+            [stepGroups]="wizardStepGroups"
+            [state]="state"
+            [progressPercent]="progressPercent"
+            [currentStepTitle]="currentStepTitle"
+            [currentStepDescription]="currentStepDescription"
+            [disableStepIndicators]="disabled"
+            (stepSelect)="onWizardStepIndicatorSelect($event)"
+          />
+        }
+
+        <!-- Navigazione sopra il form -->
+        @if (showTopNav) {
+          <ui-wizard-footer
+            class="ui-form-wizard__footer ui-form-wizard__footer--top"
+            [config]="wizardConfig"
+            [state]="state"
+            [isLastStep]="isLastStep"
+            (previous)="goToPreviousStep()"
+            (next)="goToNextStep()"
+            (finish)="finishWizard()"
+            (save)="saveCurrentStep()"
+          />
+        }
+
+        <div class="ui-form-wizard__content">
+          <!-- Form builder per lo step corrente -->
+          <ui-form-builder
+            [schema]="currentStepSchema!"
+            [initialData]="mergedInitialDataForBuilder"
+            [readonly]="readonly"
+            [disabled]="disabled"
+            [loadingFor]="loadingFor"
+            [customFieldTemplates]="customFieldTemplates"
+            [customFieldTemplateFallback]="customFieldTemplateFallback"
+            (valueChange)="onValueChange($event)"
+            (validationChange)="onValidationChange($event)"
+            (customEvent)="customEvent.emit($event)"
+          />
+        </div>
+
+        <!-- Navigazione sotto il form -->
+        @if (showBottomNav) {
+          <ui-wizard-footer
+            class="ui-form-wizard__footer"
+            [config]="wizardConfig"
+            [state]="state"
+            [isLastStep]="isLastStep"
+            (previous)="goToPreviousStep()"
+            (next)="goToNextStep()"
+            (finish)="finishWizard()"
+            (save)="saveCurrentStep()"
+          />
+        }
+      </div>
+    }
+  `, styles: [".ui-form-wizard{display:flex;flex-direction:column;gap:var(--ui-spacing-6);font-family:var(--ui-font-family)}.ui-form-wizard__header{display:flex;flex-direction:column;gap:var(--ui-spacing-4);padding-bottom:var(--ui-spacing-4);border-bottom:1px solid var(--ui-color-border)}.ui-form-wizard__progress-bar{height:6px;background:var(--ui-color-bg-subtle);border-radius:var(--ui-radius-full);overflow:hidden}.ui-form-wizard__progress-fill{height:100%;background:var(--ui-color-primary);border-radius:var(--ui-radius-full);transition:width var(--ui-transition-normal)}.ui-form-wizard__progress-text{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);margin-top:var(--ui-spacing-1)}.ui-form-wizard__steps{display:flex;justify-content:space-between;align-items:flex-start;gap:var(--ui-spacing-2);position:relative}.ui-form-wizard__steps:before{content:\"\";position:absolute;top:16px;left:24px;right:24px;height:2px;background:var(--ui-color-border);z-index:0}.ui-form-wizard__step{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1);z-index:1;flex:1}.ui-form-wizard__step-trigger,.ui-form-wizard__step-static{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1);width:100%;margin:0;padding:0;border:none;background:transparent;font:inherit;color:inherit;text-align:center}.ui-form-wizard__step-trigger{cursor:pointer;border-radius:var(--ui-radius-md);transition:background-color var(--ui-transition-fast)}.ui-form-wizard__step-trigger:hover{background-color:var(--ui-color-bg-subtle)}.ui-form-wizard__step-trigger:focus-visible{outline:2px solid var(--ui-color-primary);outline-offset:2px}.ui-form-wizard__step-static{cursor:default}.ui-form-wizard__step--navigable:not(.ui-form-wizard__step--current) .ui-form-wizard__step-trigger:hover .ui-form-wizard__step-label{color:var(--ui-color-primary)}.ui-form-wizard__step-circle{width:32px;height:32px;border-radius:var(--ui-radius-full);display:flex;align-items:center;justify-content:center;border:2px solid var(--ui-color-border);background:var(--ui-color-surface);font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-weight-semibold);color:var(--ui-color-text-muted);transition:background-color var(--ui-transition-fast),border-color var(--ui-transition-fast),color var(--ui-transition-fast)}.ui-form-wizard__step--current .ui-form-wizard__step-circle{border-color:var(--ui-color-primary);background:var(--ui-color-primary);color:#fff}.ui-form-wizard__step--completed .ui-form-wizard__step-circle{border-color:var(--ui-color-success, #16a34a);background:var(--ui-color-success, #16a34a);color:#fff}.ui-form-wizard__step--visited:not(.ui-form-wizard__step--current):not(.ui-form-wizard__step--completed) .ui-form-wizard__step-circle{border-color:var(--ui-color-primary);color:var(--ui-color-primary)}.ui-form-wizard__step-label{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);text-align:center;max-width:100px;line-height:1.3}.ui-form-wizard__step--current .ui-form-wizard__step-label{color:var(--ui-color-primary);font-weight:var(--ui-font-weight-semibold)}.ui-form-wizard__step-info{text-align:center}.ui-form-wizard__step-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-wizard__step-description{font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary);margin:0 0 var(--ui-spacing-1)}.ui-form-wizard__step-counter{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted)}.ui-form-wizard__footer{display:flex;justify-content:space-between;align-items:center;width:100%}.ui-form-wizard__footer--top{padding-top:0;padding-bottom:var(--ui-spacing-4);border-top:none;border-bottom:1px solid var(--ui-color-border)}.ui-form-wizard__footer-right{display:flex;gap:var(--ui-spacing-3)}.ui-form-wizard__nav-action{display:flex;flex-direction:column;align-items:center;gap:var(--ui-spacing-1)}.ui-form-wizard__nav-hint{font-size:var(--ui-font-size-xs);color:var(--ui-color-text-muted);line-height:1}\n"] }]
+        }], propDecorators: { formBuilder: [{
+                type: ViewChild,
+                args: [UiFormBuilderComponent]
+            }], schema: [{
+                type: Input
+            }], wizardConfig: [{
+                type: Input
+            }], customValidationMethods: [{
+                type: Input
+            }], initialData: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], loadingFor: [{
+                type: Input
+            }], customFieldTemplates: [{
+                type: Input
+            }], customFieldTemplateFallback: [{
+                type: Input
+            }], stepChange: [{
+                type: Output
+            }], stepComplete: [{
+                type: Output
+            }], stepValidationFailed: [{
+                type: Output
+            }], wizardComplete: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], validationChange: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }], onDocumentKeydown: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-wizard.component.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/form-wizard.component.ts"],"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  OnDestroy,\r\n  ChangeDetectorRef,\r\n  ViewEncapsulation,\r\n  ViewChild,\r\n  inject,\r\n  TemplateRef,\r\n  HostListener,\r\n} from '@angular/core';\r\nimport { LucideAngularModule } from 'lucide-angular';\r\nimport { Subject, takeUntil } from 'rxjs';\r\nimport { UiButtonComponent } from '../../components/button/index';\r\n\r\nimport { UiFormBuilderComponent } from './form-builder.component';\r\nimport {\r\n  UiFormSchema,\r\n  UiFormSection,\r\n  UiFormData,\r\n  UiWizardConfig,\r\n  UiWizardState,\r\n  UiWizardStepChangeEvent,\r\n  UiWizardStepCompleteEvent,\r\n  UiWizardValidationFn,\r\n  UiFormCustomEvent,\r\n} from './types/schema.types';\r\nimport {\r\n  UiFormErrorDetail,\r\n  UiFormValidationState,\r\n} from './types/validation.types';\r\nimport {\r\n  UiWizardSyncService,\r\n  UiWizardSyncData,\r\n} from './services/wizard-sync.service';\r\nimport { UiLoggerService } from '../../core/logging/logger.service';\r\n\r\n// ─── Componenti interni ───────────────────────────────────────────\r\n\r\n/**\r\n * Header del wizard: progresso e info dello step corrente.\r\n * Con `progressStyle: 'steps'` emette `stepSelect` per saltare a uno step già completato.\r\n */\r\n@Component({\r\n  selector: 'ui-wizard-header',\r\n  standalone: true,\r\n  imports: [LucideAngularModule],\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    <div class=\"ui-form-wizard__header\">\r\n      @if (config.showProgress !== false) {\r\n        @if (config.progressStyle !== 'steps') {\r\n          <div class=\"ui-form-wizard__progress-bar\">\r\n            <div\r\n              class=\"ui-form-wizard__progress-fill\"\r\n              [style.width.%]=\"progressPercent\"\r\n            ></div>\r\n          </div>\r\n          <span class=\"ui-form-wizard__progress-text\">\r\n            {{ progressPercent }}% completato\r\n          </span>\r\n        } @else {\r\n          <div class=\"ui-form-wizard__steps\">\r\n            @for (\r\n              group of stepGroups;\r\n              track $index;\r\n              let i = $index\r\n            ) {\r\n              <div\r\n                class=\"ui-form-wizard__step\"\r\n                [class.ui-form-wizard__step--current]=\"\r\n                  i === state.currentStep\r\n                \"\r\n                [class.ui-form-wizard__step--completed]=\"\r\n                  state.completedSteps.has(i)\r\n                \"\r\n                [class.ui-form-wizard__step--visited]=\"\r\n                  state.visitedSteps.has(i)\r\n                \"\r\n                [class.ui-form-wizard__step--navigable]=\"\r\n                  isStepIndicatorNavigable(i)\r\n                \"\r\n              >\r\n                @if (isStepIndicatorNavigable(i)) {\r\n                  <button\r\n                    type=\"button\"\r\n                    class=\"ui-form-wizard__step-trigger\"\r\n                    [attr.aria-label]=\"\r\n                      stepAriaLabel(\r\n                        group[0].wizardStep?.stepTitle ||\r\n                          group[0].title ||\r\n                          'Step ' + (i + 1)\r\n                      )\r\n                    \"\r\n                    (click)=\"stepSelect.emit(i)\"\r\n                  >\r\n                    <div class=\"ui-form-wizard__step-circle\">\r\n                      @if (state.completedSteps.has(i)) {\r\n                        <lucide-icon name=\"check\" [size]=\"16\" />\r\n                      } @else {\r\n                        <span>{{ i + 1 }}</span>\r\n                      }\r\n                    </div>\r\n                    <div class=\"ui-form-wizard__step-label\">\r\n                      {{\r\n                        group[0].wizardStep?.stepTitle ||\r\n                          group[0].title ||\r\n                          'Step ' + (i + 1)\r\n                      }}\r\n                    </div>\r\n                  </button>\r\n                } @else {\r\n                  <div\r\n                    class=\"ui-form-wizard__step-static\"\r\n                    [attr.aria-current]=\"\r\n                      i === state.currentStep ? 'step' : null\r\n                    \"\r\n                  >\r\n                    <div class=\"ui-form-wizard__step-circle\">\r\n                      @if (state.completedSteps.has(i)) {\r\n                        <lucide-icon name=\"check\" [size]=\"16\" />\r\n                      } @else {\r\n                        <span>{{ i + 1 }}</span>\r\n                      }\r\n                    </div>\r\n                    <div class=\"ui-form-wizard__step-label\">\r\n                      {{\r\n                        group[0].wizardStep?.stepTitle ||\r\n                          group[0].title ||\r\n                          'Step ' + (i + 1)\r\n                      }}\r\n                    </div>\r\n                  </div>\r\n                }\r\n              </div>\r\n            }\r\n          </div>\r\n        }\r\n      }\r\n\r\n      <div class=\"ui-form-wizard__step-info\">\r\n        <h2 class=\"ui-form-wizard__step-title\">{{ currentStepTitle }}</h2>\r\n        @if (currentStepDescription) {\r\n          <p class=\"ui-form-wizard__step-description\">\r\n            {{ currentStepDescription }}\r\n          </p>\r\n        }\r\n        <span class=\"ui-form-wizard__step-counter\">\r\n          Passo {{ state.currentStep + 1 }} di {{ state.totalSteps }}\r\n        </span>\r\n      </div>\r\n    </div>\r\n  `,\r\n})\r\nexport class UiWizardHeaderComponent {\r\n  @Input() config!: UiWizardConfig;\r\n  @Input() stepGroups: UiFormSection[][] = [];\r\n  @Input() state!: UiWizardState;\r\n  @Input() progressPercent = 0;\r\n  @Input() currentStepTitle = '';\r\n  @Input() currentStepDescription = '';\r\n  /** Quando true, i bullet step non sono interattivi (es. wizard disabilitato). */\r\n  @Input() disableStepIndicators = false;\r\n\r\n  @Output() stepSelect = new EventEmitter<number>();\r\n\r\n  /** Indice step selezionabile tramite bullet/titolo (solo step già completati, non il corrente). */\r\n  isStepIndicatorNavigable(stepIndex: number): boolean {\r\n    if (this.config.allowStepIndicatorNavigation === false) return false;\r\n    if (this.disableStepIndicators) return false;\r\n    if (this.config.allowBackNavigation === false) return false;\r\n    return (\r\n      stepIndex !== this.state.currentStep &&\r\n      this.state.completedSteps.has(stepIndex)\r\n    );\r\n  }\r\n\r\n  /** Testo accessibile per il pulsante step (navigazione). */\r\n  stepAriaLabel(stepTitle: string): string {\r\n    return `Vai allo step: ${stepTitle}`;\r\n  }\r\n}\r\n\r\n/**\r\n * Footer del wizard: pulsanti di navigazione e salvataggio.\r\n * Emette eventi per Previous, Next, Finish, Save.\r\n */\r\n@Component({\r\n  selector: 'ui-wizard-footer',\r\n  standalone: true,\r\n  imports: [UiButtonComponent],\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    <div class=\"ui-form-wizard__footer\">\r\n      @if (\r\n        config.allowBackNavigation !== false && state.currentStep > 0\r\n      ) {\r\n        <div class=\"ui-form-wizard__nav-action\">\r\n          <ui-button\r\n            [label]=\"config.buttonLabels?.previous ?? 'Indietro'\"\r\n            variant=\"outline\"\r\n            icon=\"chevron-left\"\r\n            (click)=\"previous.emit()\"\r\n          />\r\n          <span class=\"ui-form-wizard__nav-hint\">Ctrl + ←</span>\r\n        </div>\r\n      } @else {\r\n        <div></div>\r\n      }\r\n\r\n      <div class=\"ui-form-wizard__footer-right\">\r\n        @if (config.autoSave && config.buttonLabels?.save) {\r\n          <ui-button\r\n            [label]=\"config.buttonLabels!.save!\"\r\n            variant=\"outline\"\r\n            (click)=\"save.emit()\"\r\n          />\r\n        }\r\n        <div class=\"ui-form-wizard__nav-action\">\r\n          @if (isLastStep) {\r\n            <ui-button\r\n              [label]=\"config.buttonLabels?.finish ?? 'Completa'\"\r\n              variant=\"primary\"\r\n              icon=\"check\"\r\n              iconPosition=\"trailing\"\r\n              (click)=\"finish.emit()\"\r\n            />\r\n          } @else {\r\n            <ui-button\r\n              [label]=\"\r\n                config.buttonLabels?.next ??\r\n                  config.buttonLabels?.submit ??\r\n                  'Avanti'\r\n              \"\r\n              variant=\"primary\"\r\n              icon=\"chevron-right\"\r\n              iconPosition=\"trailing\"\r\n              (click)=\"next.emit()\"\r\n            />\r\n          }\r\n          <span class=\"ui-form-wizard__nav-hint\">Ctrl + →</span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n})\r\nexport class UiWizardFooterComponent {\r\n  @Input() config!: UiWizardConfig;\r\n  @Input() state!: UiWizardState;\r\n  @Input() isLastStep = false;\r\n\r\n  @Output() previous = new EventEmitter<void>();\r\n  @Output() next = new EventEmitter<void>();\r\n  @Output() finish = new EventEmitter<void>();\r\n  @Output() save = new EventEmitter<void>();\r\n}\r\n\r\n// ─── Componente wizard principale ─────────────────────────────────\r\n\r\n/**\r\n * Componente wizard che wrappa `UiFormBuilderComponent`\r\n * aggiungendo navigazione multi-step, barra di progresso,\r\n * validazione per step e sincronizzazione wireless.\r\n * Più sezioni schema con lo stesso `wizardStep.stepNumber` formano un unico passo\r\n * (es. più blocchi collassabili per step); metadati del passo dalla prima sezione del gruppo.\r\n *\r\n * @selector ui-form-wizard\r\n *\r\n * @example\r\n * ```html\r\n * <ui-form-wizard\r\n *   [schema]=\"wizardSchema\"\r\n *   [wizardConfig]=\"wizardConfig\"\r\n *   (wizardComplete)=\"onComplete($event)\"\r\n *   (stepChange)=\"onStepChange($event)\"\r\n * />\r\n * ```\r\n */\r\n@Component({\r\n  selector: 'ui-form-wizard',\r\n  standalone: true,\r\n  imports: [\r\n    LucideAngularModule,\r\n    UiButtonComponent,\r\n    UiFormBuilderComponent,\r\n    UiWizardHeaderComponent,\r\n    UiWizardFooterComponent,\r\n  ],\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    @if (schema && wizardConfig) {\r\n      <div class=\"ui-form-wizard\">\r\n        <!-- Header wizard (nascosto se wireless) -->\r\n        @if (!wizardConfig.wirelessHeading) {\r\n          <ui-wizard-header\r\n            [config]=\"wizardConfig\"\r\n            [stepGroups]=\"wizardStepGroups\"\r\n            [state]=\"state\"\r\n            [progressPercent]=\"progressPercent\"\r\n            [currentStepTitle]=\"currentStepTitle\"\r\n            [currentStepDescription]=\"currentStepDescription\"\r\n            [disableStepIndicators]=\"disabled\"\r\n            (stepSelect)=\"onWizardStepIndicatorSelect($event)\"\r\n          />\r\n        }\r\n\r\n        <!-- Navigazione sopra il form -->\r\n        @if (showTopNav) {\r\n          <ui-wizard-footer\r\n            class=\"ui-form-wizard__footer ui-form-wizard__footer--top\"\r\n            [config]=\"wizardConfig\"\r\n            [state]=\"state\"\r\n            [isLastStep]=\"isLastStep\"\r\n            (previous)=\"goToPreviousStep()\"\r\n            (next)=\"goToNextStep()\"\r\n            (finish)=\"finishWizard()\"\r\n            (save)=\"saveCurrentStep()\"\r\n          />\r\n        }\r\n\r\n        <div class=\"ui-form-wizard__content\">\r\n          <!-- Form builder per lo step corrente -->\r\n          <ui-form-builder\r\n            [schema]=\"currentStepSchema!\"\r\n            [initialData]=\"mergedInitialDataForBuilder\"\r\n            [readonly]=\"readonly\"\r\n            [disabled]=\"disabled\"\r\n            [loadingFor]=\"loadingFor\"\r\n            [customFieldTemplates]=\"customFieldTemplates\"\r\n            [customFieldTemplateFallback]=\"customFieldTemplateFallback\"\r\n            (valueChange)=\"onValueChange($event)\"\r\n            (validationChange)=\"onValidationChange($event)\"\r\n            (customEvent)=\"customEvent.emit($event)\"\r\n          />\r\n        </div>\r\n\r\n        <!-- Navigazione sotto il form -->\r\n        @if (showBottomNav) {\r\n          <ui-wizard-footer\r\n            class=\"ui-form-wizard__footer\"\r\n            [config]=\"wizardConfig\"\r\n            [state]=\"state\"\r\n            [isLastStep]=\"isLastStep\"\r\n            (previous)=\"goToPreviousStep()\"\r\n            (next)=\"goToNextStep()\"\r\n            (finish)=\"finishWizard()\"\r\n            (save)=\"saveCurrentStep()\"\r\n          />\r\n        }\r\n      </div>\r\n    }\r\n  `,\r\n  styleUrl: './form-wizard.component.scss',\r\n})\r\nexport class UiFormWizardComponent implements OnInit, OnDestroy {\r\n  private readonly cdr = inject(ChangeDetectorRef);\r\n  private readonly wizardSync = inject(UiWizardSyncService);\r\n  private readonly logger = inject(UiLoggerService, { optional: true });\r\n  private readonly destroy$ = new Subject<void>();\r\n\r\n  @ViewChild(UiFormBuilderComponent) formBuilder?: UiFormBuilderComponent;\r\n\r\n  // ─── Input ──────────────────────────────────────────────────────\r\n\r\n  /** Schema completo del form (tutte le sezioni con wizardStep). */\r\n  @Input() schema!: UiFormSchema;\r\n\r\n  /** Configurazione del wizard. */\r\n  @Input() wizardConfig!: UiWizardConfig;\r\n\r\n  /** Metodi di validazione custom per step. */\r\n  @Input() customValidationMethods: Record<string, UiWizardValidationFn> = {};\r\n\r\n  /** Dati iniziali. */\r\n  @Input() initialData: UiFormData = {};\r\n\r\n  /** Modalita sola lettura. */\r\n  @Input() readonly = false;\r\n\r\n  /** Stato disabilitato. */\r\n  @Input() disabled = false;\r\n\r\n  /** Pulsante in caricamento. */\r\n  @Input() loadingFor: string | null = null;\r\n\r\n  /** Template per campi `type: 'custom'` (inoltro al form builder). */\r\n  @Input() customFieldTemplates: Record<string, TemplateRef<unknown>> = {};\r\n\r\n  /** Fallback template per campi custom (inoltro al form builder). */\r\n  @Input() customFieldTemplateFallback?: TemplateRef<unknown>;\r\n\r\n  // ─── Output ─────────────────────────────────────────────────────\r\n\r\n  @Output() stepChange = new EventEmitter<UiWizardStepChangeEvent>();\r\n  @Output() stepComplete = new EventEmitter<UiWizardStepCompleteEvent>();\r\n  @Output() stepValidationFailed = new EventEmitter<{\r\n    step: number;\r\n    errors: string[];\r\n  }>();\r\n  @Output() wizardComplete = new EventEmitter<UiFormData>();\r\n  @Output() valueChange = new EventEmitter<UiFormData>();\r\n  @Output() validationChange = new EventEmitter<UiFormValidationState>();\r\n  @Output() customEvent = new EventEmitter<UiFormCustomEvent>();\r\n\r\n  // ─── Stato ──────────────────────────────────────────────────────\r\n\r\n  state: UiWizardState = {\r\n    currentStep: 0,\r\n    totalSteps: 0,\r\n    completedSteps: new Set<number>(),\r\n    visitedSteps: new Set<number>([0]),\r\n    isValid: false,\r\n    stepErrors: {},\r\n  };\r\n\r\n  /**\r\n   * Gruppi di sezioni schema per passo logico del wizard.\r\n   * Sezioni con lo stesso `wizardStep.stepNumber` compongono un unico passo (ordine: come in `schema.sections` dopo sort per numero).\r\n   */\r\n  wizardStepGroups: UiFormSection[][] = [];\r\n\r\n  /** Dati accumulati del form. */\r\n  private accumulatedData: UiFormData = {};\r\n\r\n  /**\r\n   * Schema cachato per lo step corrente.\r\n   * Evita di creare un nuovo oggetto ad ogni ciclo di change detection,\r\n   * cosa che causerebbe rebuild infiniti nel form builder.\r\n   */\r\n  _cachedStepSchema: UiFormSchema | null = null;\r\n  private _cachedStepIndex: number = -1;\r\n\r\n  // ─── Getter calcolati ───────────────────────────────────────────\r\n\r\n  get currentStepSchema(): UiFormSchema | null {\r\n    // Se lo step non e cambiato, restituisci lo schema cachato\r\n    if (\r\n      this._cachedStepIndex === this.state.currentStep &&\r\n      this._cachedStepSchema\r\n    ) {\r\n      return this._cachedStepSchema;\r\n    }\r\n\r\n    const group = this.wizardStepGroups[this.state.currentStep];\r\n    if (!group?.length) return null;\r\n\r\n    this._cachedStepSchema = {\r\n      id: this.schema.id + '-step-' + this.state.currentStep,\r\n      sections: group,\r\n      config: { ...this.schema.config, hideFooter: true, showButtons: false },\r\n    };\r\n    this._cachedStepIndex = this.state.currentStep;\r\n    return this._cachedStepSchema;\r\n  }\r\n\r\n  get currentStepTitle(): string {\r\n    const primary = this.wizardStepGroups[this.state.currentStep]?.[0];\r\n    return primary?.wizardStep?.stepTitle || primary?.title || '';\r\n  }\r\n\r\n  get currentStepDescription(): string {\r\n    const primary = this.wizardStepGroups[this.state.currentStep]?.[0];\r\n    return primary?.wizardStep?.stepDescription || primary?.description || '';\r\n  }\r\n\r\n  get isLastStep(): boolean {\r\n    return this.state.currentStep >= this.state.totalSteps - 1;\r\n  }\r\n\r\n  get progressPercent(): number {\r\n    if (this.state.totalSteps <= 1) return 100;\r\n    return Math.round(\r\n      (this.state.currentStep / (this.state.totalSteps - 1)) * 100,\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Dati passati al form builder: unione tra valori forniti dal consumer e\r\n   * stato accumulato tra gli step. Senza questo, tornando indietro il builder\r\n   * riceverebbe solo `initialData` e ricreerebbe i campi vuoti, pur avendo\r\n   * i valori ancora in `accumulatedData`.\r\n   */\r\n  get mergedInitialDataForBuilder(): UiFormData {\r\n    return { ...this.initialData, ...this.accumulatedData };\r\n  }\r\n\r\n  /** Mostra la navigazione sopra il form builder. */\r\n  get showTopNav(): boolean {\r\n    if (this.wizardConfig.showNavigationButtons === false) return false;\r\n    const pos = this.wizardConfig.navigationPosition;\r\n    return pos === 'top' || pos === 'both';\r\n  }\r\n\r\n  /** Mostra la navigazione sotto il form builder. */\r\n  get showBottomNav(): boolean {\r\n    if (this.wizardConfig.showNavigationButtons === false) return false;\r\n    const pos = this.wizardConfig.navigationPosition;\r\n    return pos === 'bottom' || pos === 'both' || pos == null;\r\n  }\r\n\r\n  // ─── Lifecycle ──────────────────────────────────────────────────\r\n\r\n  ngOnInit(): void {\r\n    if (!this.schema) {\r\n      this.logger?.logWizardAction('init', { wizardId: this.wizardConfig?.wizardId, error: 'schema non presente' });\r\n      return;\r\n    }\r\n\r\n    this.wizardStepGroups = this.buildWizardStepGroups(this.schema.sections);\r\n    this.state.totalSteps = this.wizardStepGroups.length;\r\n    this.accumulatedData = { ...this.initialData };\r\n\r\n    this.logger?.logWizardAction('init', {\r\n      wizardId: this.wizardConfig?.wizardId,\r\n      schemaId: this.schema.id,\r\n      totalSteps: this.state.totalSteps,\r\n      totalSections: this.wizardStepGroups.reduce((sum, g) => sum + g.length, 0),\r\n    });\r\n\r\n    // Sincronizzazione wireless\r\n    if (this.wizardConfig.wizardId) {\r\n      this.syncWizardState();\r\n\r\n      // Ascolta navigazione esterna\r\n      this.wizardSync\r\n        .getWizardState$(this.wizardConfig.wizardId)\r\n        .pipe(takeUntil(this.destroy$))\r\n        .subscribe((data) => {\r\n          if (data && data.wizardState.currentStep !== this.state.currentStep) {\r\n            this.navigateToStep(data.wizardState.currentStep);\r\n          }\r\n        });\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.logger?.logWizardAction('destroy', {\r\n      wizardId: this.wizardConfig?.wizardId,\r\n      schemaId: this.schema?.id,\r\n      currentStep: this.state.currentStep,\r\n    });\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    if (this.wizardConfig?.wizardId) {\r\n      this.wizardSync.unregisterWizard(this.wizardConfig.wizardId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Scorciatoia: Ctrl + Freccia sinistra/destra per navigare come i pulsanti\r\n   * Indietro / Avanti (sull'ultimo step, Avanti equivale a Completa).\r\n   * Ignorata se il focus è in un campo di input per non interferire con la digitazione.\r\n   */\r\n  @HostListener('document:keydown', ['$event'])\r\n  onDocumentKeydown(event: KeyboardEvent): void {\r\n    if (!this.schema || !this.wizardConfig || this.disabled) return;\r\n    if (this.wizardConfig.showNavigationButtons === false) return;\r\n    if (!event.ctrlKey || event.altKey || event.metaKey || event.shiftKey)\r\n      return;\r\n    if (event.key !== 'ArrowLeft' && event.key !== 'ArrowRight') return;\r\n    if (this.isEditableKeyboardTarget(event.target)) return;\r\n\r\n    if (event.key === 'ArrowLeft') {\r\n      if (this.wizardConfig.allowBackNavigation === false) return;\r\n      if (this.state.currentStep <= 0) return;\r\n      event.preventDefault();\r\n      this.logger?.logWizardAction('keyboardNavigation', {\r\n        wizardId: this.wizardConfig.wizardId,\r\n        direction: 'previous',\r\n        fromStep: this.state.currentStep,\r\n      });\r\n      this.goToPreviousStep();\r\n      return;\r\n    }\r\n\r\n    // ArrowRight\r\n    event.preventDefault();\r\n    this.logger?.logWizardAction('keyboardNavigation', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      direction: this.isLastStep ? 'finish' : 'next',\r\n      fromStep: this.state.currentStep,\r\n    });\r\n    if (this.isLastStep) {\r\n      void this.finishWizard();\r\n    } else {\r\n      void this.goToNextStep();\r\n    }\r\n  }\r\n\r\n  /** True se il target del keydown è un elemento dove la digitazione ha priorità sulla shortcut wizard. */\r\n  private isEditableKeyboardTarget(target: EventTarget | null): boolean {\r\n    if (!target || !(target instanceof HTMLElement)) return false;\r\n    const el = target;\r\n    if (el.isContentEditable) return true;\r\n    const tag = el.tagName;\r\n    if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true;\r\n    return false;\r\n  }\r\n\r\n  // ─── Navigazione ────────────────────────────────────────────────\r\n\r\n  /** Vai allo step successivo con validazione. */\r\n  async goToNextStep(): Promise<void> {\r\n    if (this.isLastStep) return;\r\n\r\n    // Valida step corrente\r\n    if (!(await this.validateCurrentStep())) return;\r\n\r\n    // Salva dati step corrente\r\n    this.state.completedSteps.add(this.state.currentStep);\r\n    await this.autoSaveIfNeeded();\r\n\r\n    this.navigateToStep(this.state.currentStep + 1);\r\n  }\r\n\r\n  /** Torna allo step precedente. */\r\n  goToPreviousStep(): void {\r\n    if (this.state.currentStep <= 0) return;\r\n    this.navigateToStep(this.state.currentStep - 1);\r\n  }\r\n\r\n  /**\r\n   * Navigazione tramite indicatori step (bullet + titolo) quando `progressStyle` è `'steps'`.\r\n   * Consentito solo verso step già marcati completati.\r\n   */\r\n  onWizardStepIndicatorSelect(stepIndex: number): void {\r\n    if (this.disabled) return;\r\n    if (this.wizardConfig.allowStepIndicatorNavigation === false) return;\r\n    if (this.wizardConfig.allowBackNavigation === false) return;\r\n    if (stepIndex === this.state.currentStep) return;\r\n    if (!this.state.completedSteps.has(stepIndex)) return;\r\n\r\n    this.logger?.logWizardAction('navigation', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      via: 'stepIndicator',\r\n      fromStep: this.state.currentStep,\r\n      toStep: stepIndex,\r\n    });\r\n    this.navigateToStep(stepIndex);\r\n  }\r\n\r\n  /** Completa il wizard. */\r\n  async finishWizard(): Promise<void> {\r\n    if (!(await this.validateCurrentStep())) {\r\n      this.logger?.logWizardAction('stepValidationFailed', {\r\n        wizardId: this.wizardConfig.wizardId,\r\n        step: this.state.currentStep,\r\n        context: 'finish',\r\n      });\r\n      return;\r\n    }\r\n\r\n    this.state.completedSteps.add(this.state.currentStep);\r\n    await this.autoSaveIfNeeded();\r\n\r\n    this.logger?.logWizardAction('complete', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      schemaId: this.schema?.id,\r\n      totalSteps: this.state.totalSteps,\r\n      completedSteps: Array.from(this.state.completedSteps),\r\n    });\r\n    this.wizardComplete.emit(this.accumulatedData);\r\n  }\r\n\r\n  /** Salva lo step corrente manualmente. */\r\n  async saveCurrentStep(): Promise<void> {\r\n    if (this.wizardConfig.onStepSave) {\r\n      const data = this.formBuilder?.getFormValue() || {};\r\n      this.logger?.logWizardAction('save', {\r\n        wizardId: this.wizardConfig.wizardId,\r\n        step: this.state.currentStep,\r\n        schemaId: this.schema?.id,\r\n      });\r\n      await this.wizardConfig.onStepSave(data, this.state.currentStep);\r\n    }\r\n  }\r\n\r\n  // ─── Callback form builder ─────────────────────────────────────\r\n\r\n  onValueChange(data: UiFormData): void {\r\n    this.accumulatedData = { ...this.accumulatedData, ...data };\r\n    this.logger?.logWizardAction('valueChange', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      step: this.state.currentStep,\r\n      schemaId: this.schema?.id,\r\n      changedKeys: Object.keys(data),\r\n    });\r\n    this.valueChange.emit(this.accumulatedData);\r\n  }\r\n\r\n  onValidationChange(state: UiFormValidationState): void {\r\n    this.state.isValid = state.valid;\r\n    this.validationChange.emit(state);\r\n  }\r\n\r\n  // ─── Navigazione interna ───────────────────────────────────────\r\n\r\n  private navigateToStep(targetStep: number): void {\r\n    if (targetStep < 0 || targetStep >= this.state.totalSteps) return;\r\n\r\n    const from = this.state.currentStep;\r\n    this.state.currentStep = targetStep;\r\n    this.state.visitedSteps.add(targetStep);\r\n\r\n    // Invalida la cache per forzare la creazione di un nuovo schema\r\n    this._cachedStepSchema = null;\r\n    this._cachedStepIndex = -1;\r\n\r\n    this.logger?.logWizardAction('stepChange', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      from,\r\n      to: targetStep,\r\n      direction: targetStep > from ? 'next' : 'previous',\r\n      schemaId: this.schema?.id,\r\n    });\r\n\r\n    this.stepChange.emit({\r\n      from,\r\n      to: targetStep,\r\n      direction: targetStep > from ? 'next' : 'previous',\r\n    });\r\n\r\n    this.syncWizardState();\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  private async validateCurrentStep(): Promise<boolean> {\r\n    this.formBuilder?.validateAllFields();\r\n    const group = this.wizardStepGroups[this.state.currentStep];\r\n    const primary = group?.[0];\r\n    const validateCustomComponents =\r\n      primary?.wizardStep?.validation?.validateCustomComponents !== false;\r\n    const customFieldKeys = new Set(this.getCustomFieldKeysForGroup(group));\r\n\r\n    const isFormValid = validateCustomComponents\r\n      ? (this.formBuilder?.isFormValid() ?? true)\r\n      : (this.formBuilder?.isFormValidExcludingFieldKeys(customFieldKeys) ??\r\n        true);\r\n\r\n    const customFnName = primary?.wizardStep?.customValidationFn;\r\n\r\n    if (customFnName && this.customValidationMethods[customFnName]) {\r\n      const customValid = await this.customValidationMethods[customFnName](\r\n        this.accumulatedData,\r\n        this.state.currentStep,\r\n        isFormValid,\r\n      );\r\n\r\n      if (!customValid) {\r\n        this.stepValidationFailed.emit({\r\n          step: this.state.currentStep,\r\n          errors: ['Validazione custom fallita'],\r\n        });\r\n        return false;\r\n      }\r\n    }\r\n\r\n    if (!isFormValid && primary?.wizardStep?.validation?.required !== false) {\r\n      let details = this.formBuilder?.getDetailedFormErrors() || [];\r\n      if (!validateCustomComponents && group?.length) {\r\n        details = this.filterErrorDetailsExcludingCustomFields(\r\n          details,\r\n          group,\r\n          customFieldKeys,\r\n        );\r\n      }\r\n      const errors = details.flatMap((e) => e.errors);\r\n      this.logger?.logWizardAction('stepValidationFailed', {\r\n        wizardId: this.wizardConfig.wizardId,\r\n        step: this.state.currentStep,\r\n        errors,\r\n      });\r\n      this.stepValidationFailed.emit({\r\n        step: this.state.currentStep,\r\n        errors,\r\n      });\r\n      return false;\r\n    }\r\n\r\n    this.logger?.logWizardAction('stepComplete', {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      step: this.state.currentStep,\r\n      schemaId: this.schema?.id,\r\n    });\r\n    this.stepComplete.emit({\r\n      step: this.state.currentStep,\r\n      data: this.formBuilder?.getFormValue() || {},\r\n    });\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Raggruppa le sezioni con `wizardStep` per `stepNumber` (ordine stabile per numero, poi ordine di apparizione nello schema).\r\n   */\r\n  private buildWizardStepGroups(sections: UiFormSection[]): UiFormSection[][] {\r\n    const withWizard = sections.filter((s) => s.wizardStep);\r\n    withWizard.sort(\r\n      (a, b) =>\r\n        (a.wizardStep!.stepNumber || 0) - (b.wizardStep!.stepNumber || 0),\r\n    );\r\n    const groups: UiFormSection[][] = [];\r\n    for (const s of withWizard) {\r\n      const num = s.wizardStep!.stepNumber;\r\n      const prev = groups[groups.length - 1];\r\n      if (\r\n        prev?.length &&\r\n        (prev[0].wizardStep!.stepNumber || 0) === (num || 0)\r\n      ) {\r\n        prev.push(s);\r\n      } else {\r\n        groups.push([s]);\r\n      }\r\n    }\r\n    return groups;\r\n  }\r\n\r\n  /** Chiavi dei campi `custom` in tutte le sezioni del passo corrente. */\r\n  private getCustomFieldKeysForGroup(\r\n    group: UiFormSection[] | undefined,\r\n  ): string[] {\r\n    if (!group?.length) return [];\r\n    const keys: string[] = [];\r\n    for (const section of group) {\r\n      for (const f of section.fields || []) {\r\n        if (f.type === 'custom') keys.push(f.key);\r\n      }\r\n    }\r\n    return keys;\r\n  }\r\n\r\n  /** Rimuove dagli errori i campi custom quando `validateCustomComponents` è false. */\r\n  private filterErrorDetailsExcludingCustomFields(\r\n    details: UiFormErrorDetail[],\r\n    group: UiFormSection[],\r\n    customKeys: Set<string>,\r\n  ): UiFormErrorDetail[] {\r\n    const sectionIds = group.map((s) => s.id);\r\n    return details.filter((d) => {\r\n      const logicalKey = this.logicalFieldKeyFromDetailKeyForGroup(\r\n        d.fieldKey,\r\n        sectionIds,\r\n      );\r\n      return !customKeys.has(logicalKey);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Risolve la chiave logica del campo rispetto a tutte le sezioni del gruppo (campi flat o repeatable).\r\n   */\r\n  private logicalFieldKeyFromDetailKeyForGroup(\r\n    fieldKey: string,\r\n    sectionIds: string[],\r\n  ): string {\r\n    for (const id of sectionIds) {\r\n      const k = this.logicalFieldKeyFromDetailKey(fieldKey, id);\r\n      if (k !== fieldKey) return k;\r\n    }\r\n    return fieldKey;\r\n  }\r\n\r\n  /** Estrae la chiave campo da `fieldKey` flat o `sectionId[i].fieldKey`. */\r\n  private logicalFieldKeyFromDetailKey(\r\n    fieldKey: string,\r\n    sectionId: string,\r\n  ): string {\r\n    const re = new RegExp(`^${this.escapeRegExp(sectionId)}\\\\[\\\\d+\\\\]\\\\.(.+)$`);\r\n    const m = fieldKey.match(re);\r\n    return m ? m[1] : fieldKey;\r\n  }\r\n\r\n  private escapeRegExp(s: string): string {\r\n    return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n  }\r\n\r\n  private async autoSaveIfNeeded(): Promise<void> {\r\n    if (this.wizardConfig.autoSave && this.wizardConfig.onStepSave) {\r\n      const data = this.formBuilder?.getFormValue() || {};\r\n      await this.wizardConfig.onStepSave(data, this.state.currentStep);\r\n    }\r\n  }\r\n\r\n  private syncWizardState(): void {\r\n    if (!this.wizardConfig.wizardId) return;\r\n\r\n    const syncData: UiWizardSyncData = {\r\n      wizardId: this.wizardConfig.wizardId,\r\n      wizardState: { ...this.state },\r\n      wizardSteps: this.wizardStepGroups.map((g) => ({\r\n        title: g[0]?.wizardStep?.stepTitle || g[0]?.title,\r\n        description: g[0]?.wizardStep?.stepDescription || g[0]?.description,\r\n      })),\r\n      isWizardMode: true,\r\n      schema: this.schema,\r\n    };\r\n\r\n    this.wizardSync.registerWizard(this.wizardConfig.wizardId, syncData);\r\n  }\r\n}\r\n"]}