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

package/esm2022/lib/components/form-builder-editor/sub-components/condition-editor/condition-editor.component.mjs

@@ -0,0 +1,667 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatCardModule } from '@angular/material/card';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { LucideAngularModule } from 'lucide-angular';
+import { UiButtonComponent } from '../../../button/index';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/card";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/select";
+import * as i6 from "@angular/material/core";
+import * as i7 from "lucide-angular";
+/**
+ * Editor per le condizioni di visibilita/disabilitazione dei campi.
+ *
+ * Permette di configurare condizioni con editor visuale o JSON.
+ * Supporta operatori di confronto multipli, logica AND/OR
+ * e selezione dei valori dalle opzioni dei campi disponibili.
+ *
+ * @selector ui-condition-editor
+ */
+export class UiConditionEditorComponent {
+    constructor() {
+        /** Lista delle condizioni da editare. */
+        this.conditions = [];
+        /** Titolo visualizzato nell'intestazione. */
+        this.title = 'Condizioni';
+        /** Campi disponibili per la selezione nelle condizioni. */
+        this.availableFields = [];
+        /** Emesso quando la lista di condizioni viene modificata. */
+        this.conditionsChange = new EventEmitter();
+        /** Indica se l'editor e in modalita JSON. */
+        this.jsonMode = false;
+        /** Testo JSON corrente nell'editor. */
+        this.jsonText = '';
+        /** Errore di parsing del JSON. */
+        this.jsonError = '';
+        /** Opzioni disponibili per gli operatori condizionali. */
+        this.operators = [
+            { value: 'equals', label: 'Uguale a' },
+            { value: 'not_equals', label: 'Diverso da' },
+            { value: 'contains', label: 'Contiene' },
+            { value: 'not_contains', label: 'Non contiene' },
+            { value: 'greater_than', label: 'Maggiore di' },
+            { value: 'less_than', label: 'Minore di' },
+            { value: 'greater_equal', label: 'Maggiore o uguale' },
+            { value: 'less_equal', label: 'Minore o uguale' },
+            { value: 'is_empty', label: 'Vuoto' },
+            { value: 'is_not_empty', label: 'Non vuoto' },
+            { value: 'in_array', label: 'Presente in lista' },
+            { value: 'not_in_array', label: 'Non presente in lista' },
+        ];
+    }
+    /**
+     * Verifica se l'operatore non richiede un campo valore.
+     * @param operator - Operatore da verificare
+     * @returns true se l'operatore non necessita di valore
+     */
+    isNoValueOperator(operator) {
+        return operator === 'is_empty' || operator === 'is_not_empty';
+    }
+    /**
+     * Verifica se l'operatore opera su array di valori.
+     * @param operator - Operatore da verificare
+     * @returns true se l'operatore richiede un array di valori
+     */
+    isArrayOperator(operator) {
+        return operator === 'in_array' || operator === 'not_in_array';
+    }
+    /**
+     * Restituisce le opzioni disponibili per un campo specifico.
+     * @param fieldKey - Chiave del campo
+     * @returns Array di opzioni del campo, vuoto se non disponibili
+     */
+    getFieldOptions(fieldKey) {
+        const field = this.availableFields.find((f) => f.key === fieldKey);
+        return field?.options || [];
+    }
+    /**
+     * Garantisce che il valore sia un array (per select multiple).
+     * @param value - Valore da normalizzare
+     * @returns Il valore come array
+     */
+    ensureArray(value) {
+        if (Array.isArray(value))
+            return value;
+        if (value == null || value === '')
+            return [];
+        return [value];
+    }
+    /**
+     * Attiva/disattiva la modalita editor JSON.
+     * In apertura serializza le condizioni, in chiusura le deserializza.
+     */
+    toggleJsonMode() {
+        if (!this.jsonMode) {
+            // Passa a modalita JSON: serializza condizioni
+            this.jsonText = this.conditions.length > 0 ? JSON.stringify(this.conditions, null, 2) : '[]';
+            this.jsonError = '';
+        }
+        else {
+            // Torna a modalita visuale: prova a parsare il JSON
+            this.applyJson();
+        }
+        this.jsonMode = !this.jsonMode;
+    }
+    /**
+     * Formatta il JSON nell'editor con indentazione.
+     */
+    formatJson() {
+        try {
+            const parsed = JSON.parse(this.jsonText);
+            this.jsonText = JSON.stringify(parsed, null, 2);
+            this.jsonError = '';
+        }
+        catch {
+            this.jsonError = 'JSON non valido: impossibile formattare.';
+        }
+    }
+    /**
+     * Gestisce il cambio del testo JSON nell'editor.
+     * Tenta il parsing e aggiorna le condizioni se valido.
+     * @param text - Testo JSON inserito dall'utente
+     */
+    onJsonChange(text) {
+        this.jsonText = text;
+        this.applyJson();
+    }
+    /**
+     * Aggiunge una nuova condizione con valori predefiniti.
+     */
+    addCondition() {
+        const firstField = this.availableFields.length > 0 ? this.availableFields[0].key : '';
+        const newCondition = {
+            field: firstField,
+            operator: 'equals',
+            value: '',
+        };
+        const updated = [...this.conditions, newCondition];
+        this.emitChange(updated);
+    }
+    /**
+     * Rimuove la condizione all'indice specificato.
+     * @param index - Indice della condizione da rimuovere
+     */
+    removeCondition(index) {
+        const updated = this.conditions.filter((_, i) => i !== index);
+        this.emitChange(updated);
+    }
+    /**
+     * Rimuove tutte le condizioni.
+     */
+    clearAll() {
+        this.emitChange([]);
+    }
+    /**
+     * Gestisce il cambio della logica di combinazione (AND/OR).
+     * @param index - Indice della condizione
+     * @param logic - Nuova logica ('AND' | 'OR')
+     */
+    onLogicChange(index, logic) {
+        const updated = this.cloneConditions();
+        updated[index] = { ...updated[index], logic };
+        this.emitChange(updated);
+    }
+    /**
+     * Gestisce il cambio del campo selezionato in una condizione.
+     * Resetta il valore quando il campo cambia.
+     * @param index - Indice della condizione
+     * @param field - Nuova chiave campo
+     */
+    onFieldChange(index, field) {
+        const updated = this.cloneConditions();
+        updated[index] = { ...updated[index], field, value: '' };
+        this.emitChange(updated);
+    }
+    /**
+     * Gestisce il cambio dell'operatore in una condizione.
+     * Resetta il valore per operatori senza valore.
+     * @param index - Indice della condizione
+     * @param operator - Nuovo operatore
+     */
+    onOperatorChange(index, operator) {
+        const updated = this.cloneConditions();
+        const condition = { ...updated[index], operator };
+        // Resetta il valore per operatori che non lo richiedono
+        if (this.isNoValueOperator(operator)) {
+            condition.value = undefined;
+        }
+        else if (this.isArrayOperator(operator) && !Array.isArray(condition.value)) {
+            // Converti a array per operatori su array
+            condition.value = condition.value ? [condition.value] : [];
+        }
+        updated[index] = condition;
+        this.emitChange(updated);
+    }
+    /**
+     * Gestisce il cambio del valore in una condizione.
+     * @param index - Indice della condizione
+     * @param value - Nuovo valore
+     */
+    onValueChange(index, value) {
+        const updated = this.cloneConditions();
+        updated[index] = { ...updated[index], value };
+        this.emitChange(updated);
+    }
+    /**
+     * Tenta di applicare il JSON corrente come array di condizioni.
+     * Aggiorna l'errore in caso di JSON non valido.
+     */
+    applyJson() {
+        try {
+            const parsed = JSON.parse(this.jsonText);
+            if (!Array.isArray(parsed)) {
+                this.jsonError = 'Il JSON deve essere un array di condizioni.';
+                return;
+            }
+            this.jsonError = '';
+            this.emitChange(parsed);
+        }
+        catch {
+            this.jsonError = 'JSON non valido: controlla la sintassi.';
+        }
+    }
+    /**
+     * Clona l'array delle condizioni per garantire immutabilita.
+     * @returns Copia superficiale dell'array di condizioni
+     */
+    cloneConditions() {
+        return this.conditions.map((c) => ({ ...c }));
+    }
+    /**
+     * Emette l'evento di cambio condizioni.
+     * @param conditions - Nuova lista di condizioni
+     */
+    emitChange(conditions) {
+        this.conditions = conditions;
+        this.conditionsChange.emit(conditions);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiConditionEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: UiConditionEditorComponent, isStandalone: true, selector: "ui-condition-editor", inputs: { conditions: "conditions", title: "title", availableFields: "availableFields" }, outputs: { conditionsChange: "conditionsChange" }, ngImport: i0, template: `
+    <!-- Intestazione con titolo, statistiche e controlli -->
+    <div class="ui-condition-editor__header">
+      <div class="ui-condition-editor__header-left">
+        <h4 class="ui-condition-editor__title">{{ title }}</h4>
+        @if (conditions.length > 0) {
+          <span class="ui-condition-editor__badge">{{ conditions.length }}</span>
+        }
+      </div>
+      <div class="ui-condition-editor__header-actions">
+        <!-- Pulsante formattazione JSON (solo in modalita JSON) -->
+        @if (jsonMode) {
+          <ui-button
+            icon="braces"
+            variant="ghost"
+            size="xs"
+            tooltip="Formatta JSON"
+            ariaLabel="Formatta JSON"
+            (click)="formatJson()"
+          />
+        }
+
+        <!-- Toggle modalita JSON/visuale -->
+        <ui-button
+          [icon]="jsonMode ? 'eye' : 'code'"
+          [variant]="jsonMode ? 'primary' : 'ghost'"
+          size="xs"
+          [tooltip]="jsonMode ? 'Editor visuale' : 'Editor JSON'"
+          [ariaLabel]="jsonMode ? 'Editor visuale' : 'Editor JSON'"
+          (click)="toggleJsonMode()"
+        />
+
+        <!-- Pulsante pulisci tutto -->
+        @if (conditions.length > 0) {
+          <ui-button
+            icon="x"
+            variant="warn"
+            size="xs"
+            tooltip="Rimuovi tutte le condizioni"
+            ariaLabel="Rimuovi tutte le condizioni"
+            (click)="clearAll()"
+          />
+        }
+      </div>
+    </div>
+
+    <!-- Editor JSON -->
+    @if (jsonMode) {
+      <div class="ui-condition-editor__json">
+        <textarea
+          class="ui-condition-editor__json-textarea"
+          [ngModel]="jsonText"
+          (ngModelChange)="onJsonChange($event)"
+          rows="8"
+          placeholder='[{ "field": "...", "operator": "equals", "value": "..." }]'
+          spellcheck="false"
+        ></textarea>
+        @if (jsonError) {
+          <div class="ui-condition-editor__json-error">
+            <lucide-icon name="alert-triangle" [size]="14" />
+            <span>{{ jsonError }}</span>
+          </div>
+        }
+      </div>
+    } @else {
+      <!-- Editor visuale -->
+      @if (availableFields.length === 0) {
+        <div class="ui-condition-editor__warning">
+          <lucide-icon name="alert-triangle" [size]="16" />
+          <span>Nessun campo disponibile per le condizioni.</span>
+        </div>
+      }
+
+      @if (conditions.length > 0) {
+        <div class="ui-condition-editor__list">
+          @for (cond of conditions; track $index) {
+            <div class="ui-condition-editor__condition-wrapper">
+              <!-- Selettore logica AND/OR (dal secondo elemento) -->
+              @if ($index > 0) {
+                <div class="ui-condition-editor__logic-row">
+                  <ui-button
+                    label="AND"
+                    [variant]="(cond.logic || 'AND') === 'AND' ? 'primary' : 'outline'"
+                    size="xs"
+                    (click)="onLogicChange($index, 'AND')"
+                  />
+                  <ui-button
+                    label="OR"
+                    [variant]="cond.logic === 'OR' ? 'primary' : 'outline'"
+                    size="xs"
+                    (click)="onLogicChange($index, 'OR')"
+                  />
+                </div>
+              }
+
+              <mat-card class="ui-condition-editor__card" appearance="outlined">
+                <mat-card-content>
+                  <div class="ui-condition-editor__card-grid">
+                    <!-- Selezione campo -->
+                    <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                      <mat-label>Campo</mat-label>
+                      <mat-select
+                        [ngModel]="cond.field"
+                        (ngModelChange)="onFieldChange($index, $event)"
+                      >
+                        @for (f of availableFields; track f.key) {
+                          <mat-option [value]="f.key">{{ f.label }}</mat-option>
+                        }
+                      </mat-select>
+                    </mat-form-field>
+
+                    <!-- Selezione operatore -->
+                    <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                      <mat-label>Operatore</mat-label>
+                      <mat-select
+                        [ngModel]="cond.operator"
+                        (ngModelChange)="onOperatorChange($index, $event)"
+                      >
+                        @for (op of operators; track op.value) {
+                          <mat-option [value]="op.value">{{ op.label }}</mat-option>
+                        }
+                      </mat-select>
+                    </mat-form-field>
+
+                    <!-- Campo valore (se l'operatore lo richiede) -->
+                    @if (!isNoValueOperator(cond.operator)) {
+                      <!-- Select multipla per in_array/not_in_array con opzioni disponibili -->
+                      @if (isArrayOperator(cond.operator) && getFieldOptions(cond.field).length > 0) {
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valori</mat-label>
+                          <mat-select
+                            [ngModel]="ensureArray(cond.value)"
+                            (ngModelChange)="onValueChange($index, $event)"
+                            multiple
+                          >
+                            @for (opt of getFieldOptions(cond.field); track opt.value) {
+                              <mat-option [value]="opt.value">{{ opt.label }}</mat-option>
+                            }
+                          </mat-select>
+                        </mat-form-field>
+                      } @else if (getFieldOptions(cond.field).length > 0 && !isArrayOperator(cond.operator)) {
+                        <!-- Select singola se il campo ha opzioni -->
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valore</mat-label>
+                          <mat-select
+                            [ngModel]="cond.value"
+                            (ngModelChange)="onValueChange($index, $event)"
+                          >
+                            @for (opt of getFieldOptions(cond.field); track opt.value) {
+                              <mat-option [value]="opt.value">{{ opt.label }}</mat-option>
+                            }
+                          </mat-select>
+                        </mat-form-field>
+                      } @else {
+                        <!-- Input testo libero -->
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valore</mat-label>
+                          <input
+                            matInput
+                            [ngModel]="cond.value"
+                            (ngModelChange)="onValueChange($index, $event)"
+                            placeholder="Inserisci valore"
+                          />
+                        </mat-form-field>
+                      }
+                    }
+
+                    <!-- Pulsante rimuovi -->
+                    <ui-button
+                      icon="trash-2"
+                      variant="warn"
+                      size="xs"
+                      tooltip="Rimuovi condizione"
+                      ariaLabel="Rimuovi condizione"
+                      (click)="removeCondition($index)"
+                    />
+                  </div>
+                </mat-card-content>
+              </mat-card>
+            </div>
+          }
+        </div>
+      } @else {
+        <!-- Stato vuoto (editor visuale) -->
+        <div class="ui-condition-editor__empty">
+          <lucide-icon name="git-branch" [size]="28" class="ui-condition-editor__empty-icon" />
+          <p class="ui-condition-editor__empty-text">Nessuna condizione configurata.</p>
+        </div>
+      }
+
+      <!-- Pulsante aggiungi condizione -->
+      <ui-button
+        label="Aggiungi condizione"
+        icon="plus"
+        variant="outline"
+        size="sm"
+        [disabled]="availableFields.length === 0"
+        (click)="addCondition()"
+      />
+    }
+  `, isInline: true, styles: [":host{display:block}.ui-condition-editor__header{display:flex;align-items:center;justify-content:space-between;margin-bottom:var(--ui-spacing-3)}.ui-condition-editor__header-left{display:flex;align-items:center;gap:var(--ui-spacing-2)}.ui-condition-editor__title{margin:0;font-size:var(--ui-font-size-sm);font-weight:600;color:var(--ui-color-text)}.ui-condition-editor__badge{display:inline-flex;align-items:center;justify-content:center;min-width:20px;height:20px;padding:0 var(--ui-spacing-1);border-radius:10px;background:var(--ui-color-primary);color:var(--ui-color-surface);font-size:var(--ui-font-size-xs);font-weight:600;line-height:1}.ui-condition-editor__header-actions{display:flex;align-items:center;gap:var(--ui-spacing-1)}.ui-condition-editor__json{display:flex;flex-direction:column;gap:var(--ui-spacing-2)}.ui-condition-editor__json-textarea{width:100%;min-height:120px;padding:var(--ui-spacing-3);border:1px solid var(--ui-color-border);border-radius:var(--ui-radius-md);background:var(--ui-color-bg-subtle);color:var(--ui-color-text);font-family:Fira Code,Consolas,monospace;font-size:var(--ui-font-size-xs);line-height:1.5;resize:vertical;box-sizing:border-box;&:focus{outline:none;border-color:var(--ui-color-primary);box-shadow:0 0 0 2px color-mix(in srgb,var(--ui-color-primary) 20%,transparent)}}.ui-condition-editor__json-error{display:flex;align-items:center;gap:var(--ui-spacing-1);padding:var(--ui-spacing-2);border-radius:var(--ui-radius-sm);background:color-mix(in srgb,var(--ui-color-warn) 10%,transparent);color:var(--ui-color-warn);font-size:var(--ui-font-size-xs)}.ui-condition-editor__warning{display:flex;align-items:center;gap:var(--ui-spacing-2);padding:var(--ui-spacing-3);margin-bottom:var(--ui-spacing-3);border-radius:var(--ui-radius-sm);background:color-mix(in srgb,var(--ui-color-warn) 10%,transparent);color:var(--ui-color-warn);font-size:var(--ui-font-size-xs)}.ui-condition-editor__list{display:flex;flex-direction:column;gap:0;margin-bottom:var(--ui-spacing-3)}.ui-condition-editor__condition-wrapper{display:flex;flex-direction:column}.ui-condition-editor__logic-row{display:flex;align-items:center;justify-content:center;gap:var(--ui-spacing-1);padding:var(--ui-spacing-2) 0}.ui-condition-editor__card{background:var(--ui-color-surface);border:1px solid var(--ui-color-border);border-radius:var(--ui-radius-md);box-shadow:var(--ui-shadow-sm)}.ui-condition-editor__card-grid{display:flex;align-items:flex-start;gap:var(--ui-spacing-2);flex-wrap:wrap}.ui-condition-editor__field{flex:1;min-width:140px}.ui-condition-editor__empty{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:var(--ui-spacing-5) var(--ui-spacing-4);margin-bottom:var(--ui-spacing-3);border:1px dashed var(--ui-color-border);border-radius:var(--ui-radius-md);background:var(--ui-color-bg-subtle);text-align:center}.ui-condition-editor__empty-icon{color:var(--ui-color-text-muted);margin-bottom:var(--ui-spacing-2)}.ui-condition-editor__empty-text{margin:0;font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary)}\n"], dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i2.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i2.MatCardContent, selector: "mat-card-content" }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i4.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i5.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i7.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }, { kind: "component", type: UiButtonComponent, selector: "ui-button", inputs: ["label", "tooltip", "variant", "size", "icon", "iconPosition", "loading", "disabled", "fullWidth", "type", "ariaLabel", "customClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiConditionEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ui-condition-editor', standalone: true, imports: [
+                        FormsModule,
+                        MatCardModule,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatSelectModule,
+                        LucideAngularModule,
+                        UiButtonComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <!-- Intestazione con titolo, statistiche e controlli -->
+    <div class="ui-condition-editor__header">
+      <div class="ui-condition-editor__header-left">
+        <h4 class="ui-condition-editor__title">{{ title }}</h4>
+        @if (conditions.length > 0) {
+          <span class="ui-condition-editor__badge">{{ conditions.length }}</span>
+        }
+      </div>
+      <div class="ui-condition-editor__header-actions">
+        <!-- Pulsante formattazione JSON (solo in modalita JSON) -->
+        @if (jsonMode) {
+          <ui-button
+            icon="braces"
+            variant="ghost"
+            size="xs"
+            tooltip="Formatta JSON"
+            ariaLabel="Formatta JSON"
+            (click)="formatJson()"
+          />
+        }
+
+        <!-- Toggle modalita JSON/visuale -->
+        <ui-button
+          [icon]="jsonMode ? 'eye' : 'code'"
+          [variant]="jsonMode ? 'primary' : 'ghost'"
+          size="xs"
+          [tooltip]="jsonMode ? 'Editor visuale' : 'Editor JSON'"
+          [ariaLabel]="jsonMode ? 'Editor visuale' : 'Editor JSON'"
+          (click)="toggleJsonMode()"
+        />
+
+        <!-- Pulsante pulisci tutto -->
+        @if (conditions.length > 0) {
+          <ui-button
+            icon="x"
+            variant="warn"
+            size="xs"
+            tooltip="Rimuovi tutte le condizioni"
+            ariaLabel="Rimuovi tutte le condizioni"
+            (click)="clearAll()"
+          />
+        }
+      </div>
+    </div>
+
+    <!-- Editor JSON -->
+    @if (jsonMode) {
+      <div class="ui-condition-editor__json">
+        <textarea
+          class="ui-condition-editor__json-textarea"
+          [ngModel]="jsonText"
+          (ngModelChange)="onJsonChange($event)"
+          rows="8"
+          placeholder='[{ "field": "...", "operator": "equals", "value": "..." }]'
+          spellcheck="false"
+        ></textarea>
+        @if (jsonError) {
+          <div class="ui-condition-editor__json-error">
+            <lucide-icon name="alert-triangle" [size]="14" />
+            <span>{{ jsonError }}</span>
+          </div>
+        }
+      </div>
+    } @else {
+      <!-- Editor visuale -->
+      @if (availableFields.length === 0) {
+        <div class="ui-condition-editor__warning">
+          <lucide-icon name="alert-triangle" [size]="16" />
+          <span>Nessun campo disponibile per le condizioni.</span>
+        </div>
+      }
+
+      @if (conditions.length > 0) {
+        <div class="ui-condition-editor__list">
+          @for (cond of conditions; track $index) {
+            <div class="ui-condition-editor__condition-wrapper">
+              <!-- Selettore logica AND/OR (dal secondo elemento) -->
+              @if ($index > 0) {
+                <div class="ui-condition-editor__logic-row">
+                  <ui-button
+                    label="AND"
+                    [variant]="(cond.logic || 'AND') === 'AND' ? 'primary' : 'outline'"
+                    size="xs"
+                    (click)="onLogicChange($index, 'AND')"
+                  />
+                  <ui-button
+                    label="OR"
+                    [variant]="cond.logic === 'OR' ? 'primary' : 'outline'"
+                    size="xs"
+                    (click)="onLogicChange($index, 'OR')"
+                  />
+                </div>
+              }
+
+              <mat-card class="ui-condition-editor__card" appearance="outlined">
+                <mat-card-content>
+                  <div class="ui-condition-editor__card-grid">
+                    <!-- Selezione campo -->
+                    <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                      <mat-label>Campo</mat-label>
+                      <mat-select
+                        [ngModel]="cond.field"
+                        (ngModelChange)="onFieldChange($index, $event)"
+                      >
+                        @for (f of availableFields; track f.key) {
+                          <mat-option [value]="f.key">{{ f.label }}</mat-option>
+                        }
+                      </mat-select>
+                    </mat-form-field>
+
+                    <!-- Selezione operatore -->
+                    <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                      <mat-label>Operatore</mat-label>
+                      <mat-select
+                        [ngModel]="cond.operator"
+                        (ngModelChange)="onOperatorChange($index, $event)"
+                      >
+                        @for (op of operators; track op.value) {
+                          <mat-option [value]="op.value">{{ op.label }}</mat-option>
+                        }
+                      </mat-select>
+                    </mat-form-field>
+
+                    <!-- Campo valore (se l'operatore lo richiede) -->
+                    @if (!isNoValueOperator(cond.operator)) {
+                      <!-- Select multipla per in_array/not_in_array con opzioni disponibili -->
+                      @if (isArrayOperator(cond.operator) && getFieldOptions(cond.field).length > 0) {
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valori</mat-label>
+                          <mat-select
+                            [ngModel]="ensureArray(cond.value)"
+                            (ngModelChange)="onValueChange($index, $event)"
+                            multiple
+                          >
+                            @for (opt of getFieldOptions(cond.field); track opt.value) {
+                              <mat-option [value]="opt.value">{{ opt.label }}</mat-option>
+                            }
+                          </mat-select>
+                        </mat-form-field>
+                      } @else if (getFieldOptions(cond.field).length > 0 && !isArrayOperator(cond.operator)) {
+                        <!-- Select singola se il campo ha opzioni -->
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valore</mat-label>
+                          <mat-select
+                            [ngModel]="cond.value"
+                            (ngModelChange)="onValueChange($index, $event)"
+                          >
+                            @for (opt of getFieldOptions(cond.field); track opt.value) {
+                              <mat-option [value]="opt.value">{{ opt.label }}</mat-option>
+                            }
+                          </mat-select>
+                        </mat-form-field>
+                      } @else {
+                        <!-- Input testo libero -->
+                        <mat-form-field class="ui-condition-editor__field" appearance="outline">
+                          <mat-label>Valore</mat-label>
+                          <input
+                            matInput
+                            [ngModel]="cond.value"
+                            (ngModelChange)="onValueChange($index, $event)"
+                            placeholder="Inserisci valore"
+                          />
+                        </mat-form-field>
+                      }
+                    }
+
+                    <!-- Pulsante rimuovi -->
+                    <ui-button
+                      icon="trash-2"
+                      variant="warn"
+                      size="xs"
+                      tooltip="Rimuovi condizione"
+                      ariaLabel="Rimuovi condizione"
+                      (click)="removeCondition($index)"
+                    />
+                  </div>
+                </mat-card-content>
+              </mat-card>
+            </div>
+          }
+        </div>
+      } @else {
+        <!-- Stato vuoto (editor visuale) -->
+        <div class="ui-condition-editor__empty">
+          <lucide-icon name="git-branch" [size]="28" class="ui-condition-editor__empty-icon" />
+          <p class="ui-condition-editor__empty-text">Nessuna condizione configurata.</p>
+        </div>
+      }
+
+      <!-- Pulsante aggiungi condizione -->
+      <ui-button
+        label="Aggiungi condizione"
+        icon="plus"
+        variant="outline"
+        size="sm"
+        [disabled]="availableFields.length === 0"
+        (click)="addCondition()"
+      />
+    }
+  `, styles: [":host{display:block}.ui-condition-editor__header{display:flex;align-items:center;justify-content:space-between;margin-bottom:var(--ui-spacing-3)}.ui-condition-editor__header-left{display:flex;align-items:center;gap:var(--ui-spacing-2)}.ui-condition-editor__title{margin:0;font-size:var(--ui-font-size-sm);font-weight:600;color:var(--ui-color-text)}.ui-condition-editor__badge{display:inline-flex;align-items:center;justify-content:center;min-width:20px;height:20px;padding:0 var(--ui-spacing-1);border-radius:10px;background:var(--ui-color-primary);color:var(--ui-color-surface);font-size:var(--ui-font-size-xs);font-weight:600;line-height:1}.ui-condition-editor__header-actions{display:flex;align-items:center;gap:var(--ui-spacing-1)}.ui-condition-editor__json{display:flex;flex-direction:column;gap:var(--ui-spacing-2)}.ui-condition-editor__json-textarea{width:100%;min-height:120px;padding:var(--ui-spacing-3);border:1px solid var(--ui-color-border);border-radius:var(--ui-radius-md);background:var(--ui-color-bg-subtle);color:var(--ui-color-text);font-family:Fira Code,Consolas,monospace;font-size:var(--ui-font-size-xs);line-height:1.5;resize:vertical;box-sizing:border-box;&:focus{outline:none;border-color:var(--ui-color-primary);box-shadow:0 0 0 2px color-mix(in srgb,var(--ui-color-primary) 20%,transparent)}}.ui-condition-editor__json-error{display:flex;align-items:center;gap:var(--ui-spacing-1);padding:var(--ui-spacing-2);border-radius:var(--ui-radius-sm);background:color-mix(in srgb,var(--ui-color-warn) 10%,transparent);color:var(--ui-color-warn);font-size:var(--ui-font-size-xs)}.ui-condition-editor__warning{display:flex;align-items:center;gap:var(--ui-spacing-2);padding:var(--ui-spacing-3);margin-bottom:var(--ui-spacing-3);border-radius:var(--ui-radius-sm);background:color-mix(in srgb,var(--ui-color-warn) 10%,transparent);color:var(--ui-color-warn);font-size:var(--ui-font-size-xs)}.ui-condition-editor__list{display:flex;flex-direction:column;gap:0;margin-bottom:var(--ui-spacing-3)}.ui-condition-editor__condition-wrapper{display:flex;flex-direction:column}.ui-condition-editor__logic-row{display:flex;align-items:center;justify-content:center;gap:var(--ui-spacing-1);padding:var(--ui-spacing-2) 0}.ui-condition-editor__card{background:var(--ui-color-surface);border:1px solid var(--ui-color-border);border-radius:var(--ui-radius-md);box-shadow:var(--ui-shadow-sm)}.ui-condition-editor__card-grid{display:flex;align-items:flex-start;gap:var(--ui-spacing-2);flex-wrap:wrap}.ui-condition-editor__field{flex:1;min-width:140px}.ui-condition-editor__empty{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:var(--ui-spacing-5) var(--ui-spacing-4);margin-bottom:var(--ui-spacing-3);border:1px dashed var(--ui-color-border);border-radius:var(--ui-radius-md);background:var(--ui-color-bg-subtle);text-align:center}.ui-condition-editor__empty-icon{color:var(--ui-color-text-muted);margin-bottom:var(--ui-spacing-2)}.ui-condition-editor__empty-text{margin:0;font-size:var(--ui-font-size-sm);color:var(--ui-color-text-secondary)}\n"] }]
+        }], propDecorators: { conditions: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], availableFields: [{
+                type: Input
+            }], conditionsChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-editor.component.js","sourceRoot":"","sources":["../../../../../../../../packages/ng-ui-system/src/lib/components/form-builder-editor/sub-components/condition-editor/condition-editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { LucideAngularModule } from 'lucide-angular';\r\nimport { UiButtonComponent } from '../../../button/index';\r\nimport { UiFieldCondition, UiConditionalOperator } from '../../../form-builder/types/index';\r\nimport { UiEditorAvailableField } from '../../types/editor.types';\r\n\r\n/**\r\n * Interfaccia per le opzioni degli operatori condizionali nella select.\r\n */\r\ninterface OperatorOption {\r\n  /** Valore dell'operatore. */\r\n  value: UiConditionalOperator;\r\n  /** Etichetta visualizzata nella select. */\r\n  label: string;\r\n}\r\n\r\n/**\r\n * Editor per le condizioni di visibilita/disabilitazione dei campi.\r\n *\r\n * Permette di configurare condizioni con editor visuale o JSON.\r\n * Supporta operatori di confronto multipli, logica AND/OR\r\n * e selezione dei valori dalle opzioni dei campi disponibili.\r\n *\r\n * @selector ui-condition-editor\r\n */\r\n@Component({\r\n  selector: 'ui-condition-editor',\r\n  standalone: true,\r\n  imports: [\r\n    FormsModule,\r\n    MatCardModule,\r\n    MatFormFieldModule,\r\n    MatInputModule,\r\n    MatSelectModule,\r\n    LucideAngularModule,\r\n    UiButtonComponent,\r\n  ],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  template: `\r\n    <!-- Intestazione con titolo, statistiche e controlli -->\r\n    <div class=\"ui-condition-editor__header\">\r\n      <div class=\"ui-condition-editor__header-left\">\r\n        <h4 class=\"ui-condition-editor__title\">{{ title }}</h4>\r\n        @if (conditions.length > 0) {\r\n          <span class=\"ui-condition-editor__badge\">{{ conditions.length }}</span>\r\n        }\r\n      </div>\r\n      <div class=\"ui-condition-editor__header-actions\">\r\n        <!-- Pulsante formattazione JSON (solo in modalita JSON) -->\r\n        @if (jsonMode) {\r\n          <ui-button\r\n            icon=\"braces\"\r\n            variant=\"ghost\"\r\n            size=\"xs\"\r\n            tooltip=\"Formatta JSON\"\r\n            ariaLabel=\"Formatta JSON\"\r\n            (click)=\"formatJson()\"\r\n          />\r\n        }\r\n\r\n        <!-- Toggle modalita JSON/visuale -->\r\n        <ui-button\r\n          [icon]=\"jsonMode ? 'eye' : 'code'\"\r\n          [variant]=\"jsonMode ? 'primary' : 'ghost'\"\r\n          size=\"xs\"\r\n          [tooltip]=\"jsonMode ? 'Editor visuale' : 'Editor JSON'\"\r\n          [ariaLabel]=\"jsonMode ? 'Editor visuale' : 'Editor JSON'\"\r\n          (click)=\"toggleJsonMode()\"\r\n        />\r\n\r\n        <!-- Pulsante pulisci tutto -->\r\n        @if (conditions.length > 0) {\r\n          <ui-button\r\n            icon=\"x\"\r\n            variant=\"warn\"\r\n            size=\"xs\"\r\n            tooltip=\"Rimuovi tutte le condizioni\"\r\n            ariaLabel=\"Rimuovi tutte le condizioni\"\r\n            (click)=\"clearAll()\"\r\n          />\r\n        }\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Editor JSON -->\r\n    @if (jsonMode) {\r\n      <div class=\"ui-condition-editor__json\">\r\n        <textarea\r\n          class=\"ui-condition-editor__json-textarea\"\r\n          [ngModel]=\"jsonText\"\r\n          (ngModelChange)=\"onJsonChange($event)\"\r\n          rows=\"8\"\r\n          placeholder='[{ \"field\": \"...\", \"operator\": \"equals\", \"value\": \"...\" }]'\r\n          spellcheck=\"false\"\r\n        ></textarea>\r\n        @if (jsonError) {\r\n          <div class=\"ui-condition-editor__json-error\">\r\n            <lucide-icon name=\"alert-triangle\" [size]=\"14\" />\r\n            <span>{{ jsonError }}</span>\r\n          </div>\r\n        }\r\n      </div>\r\n    } @else {\r\n      <!-- Editor visuale -->\r\n      @if (availableFields.length === 0) {\r\n        <div class=\"ui-condition-editor__warning\">\r\n          <lucide-icon name=\"alert-triangle\" [size]=\"16\" />\r\n          <span>Nessun campo disponibile per le condizioni.</span>\r\n        </div>\r\n      }\r\n\r\n      @if (conditions.length > 0) {\r\n        <div class=\"ui-condition-editor__list\">\r\n          @for (cond of conditions; track $index) {\r\n            <div class=\"ui-condition-editor__condition-wrapper\">\r\n              <!-- Selettore logica AND/OR (dal secondo elemento) -->\r\n              @if ($index > 0) {\r\n                <div class=\"ui-condition-editor__logic-row\">\r\n                  <ui-button\r\n                    label=\"AND\"\r\n                    [variant]=\"(cond.logic || 'AND') === 'AND' ? 'primary' : 'outline'\"\r\n                    size=\"xs\"\r\n                    (click)=\"onLogicChange($index, 'AND')\"\r\n                  />\r\n                  <ui-button\r\n                    label=\"OR\"\r\n                    [variant]=\"cond.logic === 'OR' ? 'primary' : 'outline'\"\r\n                    size=\"xs\"\r\n                    (click)=\"onLogicChange($index, 'OR')\"\r\n                  />\r\n                </div>\r\n              }\r\n\r\n              <mat-card class=\"ui-condition-editor__card\" appearance=\"outlined\">\r\n                <mat-card-content>\r\n                  <div class=\"ui-condition-editor__card-grid\">\r\n                    <!-- Selezione campo -->\r\n                    <mat-form-field class=\"ui-condition-editor__field\" appearance=\"outline\">\r\n                      <mat-label>Campo</mat-label>\r\n                      <mat-select\r\n                        [ngModel]=\"cond.field\"\r\n                        (ngModelChange)=\"onFieldChange($index, $event)\"\r\n                      >\r\n                        @for (f of availableFields; track f.key) {\r\n                          <mat-option [value]=\"f.key\">{{ f.label }}</mat-option>\r\n                        }\r\n                      </mat-select>\r\n                    </mat-form-field>\r\n\r\n                    <!-- Selezione operatore -->\r\n                    <mat-form-field class=\"ui-condition-editor__field\" appearance=\"outline\">\r\n                      <mat-label>Operatore</mat-label>\r\n                      <mat-select\r\n                        [ngModel]=\"cond.operator\"\r\n                        (ngModelChange)=\"onOperatorChange($index, $event)\"\r\n                      >\r\n                        @for (op of operators; track op.value) {\r\n                          <mat-option [value]=\"op.value\">{{ op.label }}</mat-option>\r\n                        }\r\n                      </mat-select>\r\n                    </mat-form-field>\r\n\r\n                    <!-- Campo valore (se l'operatore lo richiede) -->\r\n                    @if (!isNoValueOperator(cond.operator)) {\r\n                      <!-- Select multipla per in_array/not_in_array con opzioni disponibili -->\r\n                      @if (isArrayOperator(cond.operator) && getFieldOptions(cond.field).length > 0) {\r\n                        <mat-form-field class=\"ui-condition-editor__field\" appearance=\"outline\">\r\n                          <mat-label>Valori</mat-label>\r\n                          <mat-select\r\n                            [ngModel]=\"ensureArray(cond.value)\"\r\n                            (ngModelChange)=\"onValueChange($index, $event)\"\r\n                            multiple\r\n                          >\r\n                            @for (opt of getFieldOptions(cond.field); track opt.value) {\r\n                              <mat-option [value]=\"opt.value\">{{ opt.label }}</mat-option>\r\n                            }\r\n                          </mat-select>\r\n                        </mat-form-field>\r\n                      } @else if (getFieldOptions(cond.field).length > 0 && !isArrayOperator(cond.operator)) {\r\n                        <!-- Select singola se il campo ha opzioni -->\r\n                        <mat-form-field class=\"ui-condition-editor__field\" appearance=\"outline\">\r\n                          <mat-label>Valore</mat-label>\r\n                          <mat-select\r\n                            [ngModel]=\"cond.value\"\r\n                            (ngModelChange)=\"onValueChange($index, $event)\"\r\n                          >\r\n                            @for (opt of getFieldOptions(cond.field); track opt.value) {\r\n                              <mat-option [value]=\"opt.value\">{{ opt.label }}</mat-option>\r\n                            }\r\n                          </mat-select>\r\n                        </mat-form-field>\r\n                      } @else {\r\n                        <!-- Input testo libero -->\r\n                        <mat-form-field class=\"ui-condition-editor__field\" appearance=\"outline\">\r\n                          <mat-label>Valore</mat-label>\r\n                          <input\r\n                            matInput\r\n                            [ngModel]=\"cond.value\"\r\n                            (ngModelChange)=\"onValueChange($index, $event)\"\r\n                            placeholder=\"Inserisci valore\"\r\n                          />\r\n                        </mat-form-field>\r\n                      }\r\n                    }\r\n\r\n                    <!-- Pulsante rimuovi -->\r\n                    <ui-button\r\n                      icon=\"trash-2\"\r\n                      variant=\"warn\"\r\n                      size=\"xs\"\r\n                      tooltip=\"Rimuovi condizione\"\r\n                      ariaLabel=\"Rimuovi condizione\"\r\n                      (click)=\"removeCondition($index)\"\r\n                    />\r\n                  </div>\r\n                </mat-card-content>\r\n              </mat-card>\r\n            </div>\r\n          }\r\n        </div>\r\n      } @else {\r\n        <!-- Stato vuoto (editor visuale) -->\r\n        <div class=\"ui-condition-editor__empty\">\r\n          <lucide-icon name=\"git-branch\" [size]=\"28\" class=\"ui-condition-editor__empty-icon\" />\r\n          <p class=\"ui-condition-editor__empty-text\">Nessuna condizione configurata.</p>\r\n        </div>\r\n      }\r\n\r\n      <!-- Pulsante aggiungi condizione -->\r\n      <ui-button\r\n        label=\"Aggiungi condizione\"\r\n        icon=\"plus\"\r\n        variant=\"outline\"\r\n        size=\"sm\"\r\n        [disabled]=\"availableFields.length === 0\"\r\n        (click)=\"addCondition()\"\r\n      />\r\n    }\r\n  `,\r\n  styles: [\r\n    `\r\n    :host {\r\n      display: block;\r\n    }\r\n\r\n    .ui-condition-editor__header {\r\n      display: flex;\r\n      align-items: center;\r\n      justify-content: space-between;\r\n      margin-bottom: var(--ui-spacing-3);\r\n    }\r\n\r\n    .ui-condition-editor__header-left {\r\n      display: flex;\r\n      align-items: center;\r\n      gap: var(--ui-spacing-2);\r\n    }\r\n\r\n    .ui-condition-editor__title {\r\n      margin: 0;\r\n      font-size: var(--ui-font-size-sm);\r\n      font-weight: 600;\r\n      color: var(--ui-color-text);\r\n    }\r\n\r\n    .ui-condition-editor__badge {\r\n      display: inline-flex;\r\n      align-items: center;\r\n      justify-content: center;\r\n      min-width: 20px;\r\n      height: 20px;\r\n      padding: 0 var(--ui-spacing-1);\r\n      border-radius: 10px;\r\n      background: var(--ui-color-primary);\r\n      color: var(--ui-color-surface);\r\n      font-size: var(--ui-font-size-xs);\r\n      font-weight: 600;\r\n      line-height: 1;\r\n    }\r\n\r\n    .ui-condition-editor__header-actions {\r\n      display: flex;\r\n      align-items: center;\r\n      gap: var(--ui-spacing-1);\r\n    }\r\n\r\n    /* --- Editor JSON --- */\r\n\r\n    .ui-condition-editor__json {\r\n      display: flex;\r\n      flex-direction: column;\r\n      gap: var(--ui-spacing-2);\r\n    }\r\n\r\n    .ui-condition-editor__json-textarea {\r\n      width: 100%;\r\n      min-height: 120px;\r\n      padding: var(--ui-spacing-3);\r\n      border: 1px solid var(--ui-color-border);\r\n      border-radius: var(--ui-radius-md);\r\n      background: var(--ui-color-bg-subtle);\r\n      color: var(--ui-color-text);\r\n      font-family: 'Fira Code', 'Consolas', monospace;\r\n      font-size: var(--ui-font-size-xs);\r\n      line-height: 1.5;\r\n      resize: vertical;\r\n      box-sizing: border-box;\r\n\r\n      &:focus {\r\n        outline: none;\r\n        border-color: var(--ui-color-primary);\r\n        box-shadow: 0 0 0 2px color-mix(in srgb, var(--ui-color-primary) 20%, transparent);\r\n      }\r\n    }\r\n\r\n    .ui-condition-editor__json-error {\r\n      display: flex;\r\n      align-items: center;\r\n      gap: var(--ui-spacing-1);\r\n      padding: var(--ui-spacing-2);\r\n      border-radius: var(--ui-radius-sm);\r\n      background: color-mix(in srgb, var(--ui-color-warn) 10%, transparent);\r\n      color: var(--ui-color-warn);\r\n      font-size: var(--ui-font-size-xs);\r\n    }\r\n\r\n    /* --- Avviso nessun campo disponibile --- */\r\n\r\n    .ui-condition-editor__warning {\r\n      display: flex;\r\n      align-items: center;\r\n      gap: var(--ui-spacing-2);\r\n      padding: var(--ui-spacing-3);\r\n      margin-bottom: var(--ui-spacing-3);\r\n      border-radius: var(--ui-radius-sm);\r\n      background: color-mix(in srgb, var(--ui-color-warn) 10%, transparent);\r\n      color: var(--ui-color-warn);\r\n      font-size: var(--ui-font-size-xs);\r\n    }\r\n\r\n    /* --- Lista condizioni --- */\r\n\r\n    .ui-condition-editor__list {\r\n      display: flex;\r\n      flex-direction: column;\r\n      gap: 0;\r\n      margin-bottom: var(--ui-spacing-3);\r\n    }\r\n\r\n    .ui-condition-editor__condition-wrapper {\r\n      display: flex;\r\n      flex-direction: column;\r\n    }\r\n\r\n    .ui-condition-editor__logic-row {\r\n      display: flex;\r\n      align-items: center;\r\n      justify-content: center;\r\n      gap: var(--ui-spacing-1);\r\n      padding: var(--ui-spacing-2) 0;\r\n    }\r\n\r\n    .ui-condition-editor__card {\r\n      background: var(--ui-color-surface);\r\n      border: 1px solid var(--ui-color-border);\r\n      border-radius: var(--ui-radius-md);\r\n      box-shadow: var(--ui-shadow-sm);\r\n    }\r\n\r\n    .ui-condition-editor__card-grid {\r\n      display: flex;\r\n      align-items: flex-start;\r\n      gap: var(--ui-spacing-2);\r\n      flex-wrap: wrap;\r\n    }\r\n\r\n    .ui-condition-editor__field {\r\n      flex: 1;\r\n      min-width: 140px;\r\n    }\r\n\r\n    /* --- Stato vuoto --- */\r\n\r\n    .ui-condition-editor__empty {\r\n      display: flex;\r\n      flex-direction: column;\r\n      align-items: center;\r\n      justify-content: center;\r\n      padding: var(--ui-spacing-5) var(--ui-spacing-4);\r\n      margin-bottom: var(--ui-spacing-3);\r\n      border: 1px dashed var(--ui-color-border);\r\n      border-radius: var(--ui-radius-md);\r\n      background: var(--ui-color-bg-subtle);\r\n      text-align: center;\r\n    }\r\n\r\n    .ui-condition-editor__empty-icon {\r\n      color: var(--ui-color-text-muted);\r\n      margin-bottom: var(--ui-spacing-2);\r\n    }\r\n\r\n    .ui-condition-editor__empty-text {\r\n      margin: 0;\r\n      font-size: var(--ui-font-size-sm);\r\n      color: var(--ui-color-text-secondary);\r\n    }\r\n\r\n  `,\r\n  ],\r\n})\r\nexport class UiConditionEditorComponent {\r\n  /** Lista delle condizioni da editare. */\r\n  @Input() conditions: UiFieldCondition[] = [];\r\n\r\n  /** Titolo visualizzato nell'intestazione. */\r\n  @Input() title = 'Condizioni';\r\n\r\n  /** Campi disponibili per la selezione nelle condizioni. */\r\n  @Input() availableFields: UiEditorAvailableField[] = [];\r\n\r\n  /** Emesso quando la lista di condizioni viene modificata. */\r\n  @Output() conditionsChange = new EventEmitter<UiFieldCondition[]>();\r\n\r\n  /** Indica se l'editor e in modalita JSON. */\r\n  jsonMode = false;\r\n\r\n  /** Testo JSON corrente nell'editor. */\r\n  jsonText = '';\r\n\r\n  /** Errore di parsing del JSON. */\r\n  jsonError = '';\r\n\r\n  /** Opzioni disponibili per gli operatori condizionali. */\r\n  readonly operators: OperatorOption[] = [\r\n    { value: 'equals', label: 'Uguale a' },\r\n    { value: 'not_equals', label: 'Diverso da' },\r\n    { value: 'contains', label: 'Contiene' },\r\n    { value: 'not_contains', label: 'Non contiene' },\r\n    { value: 'greater_than', label: 'Maggiore di' },\r\n    { value: 'less_than', label: 'Minore di' },\r\n    { value: 'greater_equal', label: 'Maggiore o uguale' },\r\n    { value: 'less_equal', label: 'Minore o uguale' },\r\n    { value: 'is_empty', label: 'Vuoto' },\r\n    { value: 'is_not_empty', label: 'Non vuoto' },\r\n    { value: 'in_array', label: 'Presente in lista' },\r\n    { value: 'not_in_array', label: 'Non presente in lista' },\r\n  ];\r\n\r\n  /**\r\n   * Verifica se l'operatore non richiede un campo valore.\r\n   * @param operator - Operatore da verificare\r\n   * @returns true se l'operatore non necessita di valore\r\n   */\r\n  isNoValueOperator(operator: UiConditionalOperator): boolean {\r\n    return operator === 'is_empty' || operator === 'is_not_empty';\r\n  }\r\n\r\n  /**\r\n   * Verifica se l'operatore opera su array di valori.\r\n   * @param operator - Operatore da verificare\r\n   * @returns true se l'operatore richiede un array di valori\r\n   */\r\n  isArrayOperator(operator: UiConditionalOperator): boolean {\r\n    return operator === 'in_array' || operator === 'not_in_array';\r\n  }\r\n\r\n  /**\r\n   * Restituisce le opzioni disponibili per un campo specifico.\r\n   * @param fieldKey - Chiave del campo\r\n   * @returns Array di opzioni del campo, vuoto se non disponibili\r\n   */\r\n  getFieldOptions(fieldKey: string): { value: any; label: string }[] {\r\n    const field = this.availableFields.find((f) => f.key === fieldKey);\r\n    return field?.options || [];\r\n  }\r\n\r\n  /**\r\n   * Garantisce che il valore sia un array (per select multiple).\r\n   * @param value - Valore da normalizzare\r\n   * @returns Il valore come array\r\n   */\r\n  ensureArray(value: any): any[] {\r\n    if (Array.isArray(value)) return value;\r\n    if (value == null || value === '') return [];\r\n    return [value];\r\n  }\r\n\r\n  /**\r\n   * Attiva/disattiva la modalita editor JSON.\r\n   * In apertura serializza le condizioni, in chiusura le deserializza.\r\n   */\r\n  toggleJsonMode(): void {\r\n    if (!this.jsonMode) {\r\n      // Passa a modalita JSON: serializza condizioni\r\n      this.jsonText = this.conditions.length > 0 ? JSON.stringify(this.conditions, null, 2) : '[]';\r\n      this.jsonError = '';\r\n    } else {\r\n      // Torna a modalita visuale: prova a parsare il JSON\r\n      this.applyJson();\r\n    }\r\n    this.jsonMode = !this.jsonMode;\r\n  }\r\n\r\n  /**\r\n   * Formatta il JSON nell'editor con indentazione.\r\n   */\r\n  formatJson(): void {\r\n    try {\r\n      const parsed = JSON.parse(this.jsonText);\r\n      this.jsonText = JSON.stringify(parsed, null, 2);\r\n      this.jsonError = '';\r\n    } catch {\r\n      this.jsonError = 'JSON non valido: impossibile formattare.';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gestisce il cambio del testo JSON nell'editor.\r\n   * Tenta il parsing e aggiorna le condizioni se valido.\r\n   * @param text - Testo JSON inserito dall'utente\r\n   */\r\n  onJsonChange(text: string): void {\r\n    this.jsonText = text;\r\n    this.applyJson();\r\n  }\r\n\r\n  /**\r\n   * Aggiunge una nuova condizione con valori predefiniti.\r\n   */\r\n  addCondition(): void {\r\n    const firstField = this.availableFields.length > 0 ? this.availableFields[0].key : '';\r\n    const newCondition: UiFieldCondition = {\r\n      field: firstField,\r\n      operator: 'equals',\r\n      value: '',\r\n    };\r\n    const updated = [...this.conditions, newCondition];\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Rimuove la condizione all'indice specificato.\r\n   * @param index - Indice della condizione da rimuovere\r\n   */\r\n  removeCondition(index: number): void {\r\n    const updated = this.conditions.filter((_, i) => i !== index);\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Rimuove tutte le condizioni.\r\n   */\r\n  clearAll(): void {\r\n    this.emitChange([]);\r\n  }\r\n\r\n  /**\r\n   * Gestisce il cambio della logica di combinazione (AND/OR).\r\n   * @param index - Indice della condizione\r\n   * @param logic - Nuova logica ('AND' | 'OR')\r\n   */\r\n  onLogicChange(index: number, logic: 'AND' | 'OR'): void {\r\n    const updated = this.cloneConditions();\r\n    updated[index] = { ...updated[index], logic };\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Gestisce il cambio del campo selezionato in una condizione.\r\n   * Resetta il valore quando il campo cambia.\r\n   * @param index - Indice della condizione\r\n   * @param field - Nuova chiave campo\r\n   */\r\n  onFieldChange(index: number, field: string): void {\r\n    const updated = this.cloneConditions();\r\n    updated[index] = { ...updated[index], field, value: '' };\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Gestisce il cambio dell'operatore in una condizione.\r\n   * Resetta il valore per operatori senza valore.\r\n   * @param index - Indice della condizione\r\n   * @param operator - Nuovo operatore\r\n   */\r\n  onOperatorChange(index: number, operator: UiConditionalOperator): void {\r\n    const updated = this.cloneConditions();\r\n    const condition = { ...updated[index], operator };\r\n\r\n    // Resetta il valore per operatori che non lo richiedono\r\n    if (this.isNoValueOperator(operator)) {\r\n      condition.value = undefined;\r\n    } else if (this.isArrayOperator(operator) && !Array.isArray(condition.value)) {\r\n      // Converti a array per operatori su array\r\n      condition.value = condition.value ? [condition.value] : [];\r\n    }\r\n\r\n    updated[index] = condition;\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Gestisce il cambio del valore in una condizione.\r\n   * @param index - Indice della condizione\r\n   * @param value - Nuovo valore\r\n   */\r\n  onValueChange(index: number, value: any): void {\r\n    const updated = this.cloneConditions();\r\n    updated[index] = { ...updated[index], value };\r\n    this.emitChange(updated);\r\n  }\r\n\r\n  /**\r\n   * Tenta di applicare il JSON corrente come array di condizioni.\r\n   * Aggiorna l'errore in caso di JSON non valido.\r\n   */\r\n  private applyJson(): void {\r\n    try {\r\n      const parsed = JSON.parse(this.jsonText);\r\n      if (!Array.isArray(parsed)) {\r\n        this.jsonError = 'Il JSON deve essere un array di condizioni.';\r\n        return;\r\n      }\r\n      this.jsonError = '';\r\n      this.emitChange(parsed);\r\n    } catch {\r\n      this.jsonError = 'JSON non valido: controlla la sintassi.';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clona l'array delle condizioni per garantire immutabilita.\r\n   * @returns Copia superficiale dell'array di condizioni\r\n   */\r\n  private cloneConditions(): UiFieldCondition[] {\r\n    return this.conditions.map((c) => ({ ...c }));\r\n  }\r\n\r\n  /**\r\n   * Emette l'evento di cambio condizioni.\r\n   * @param conditions - Nuova lista di condizioni\r\n   */\r\n  private emitChange(conditions: UiFieldCondition[]): void {\r\n    this.conditions = conditions;\r\n    this.conditionsChange.emit(conditions);\r\n  }\r\n}\r\n"]}