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

package/esm2022/lib/components/form-builder/services/form-condition.service.mjs

@@ -0,0 +1,132 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la valutazione delle condizioni di visibilita,
+ * required e disable dei campi del form.
+ *
+ * Supporta 12 operatori di confronto, logica AND/OR
+ * e accesso a valori annidati tramite dot notation.
+ *
+ * @providedIn 'root'
+ */
+export class UiFormConditionService {
+    /**
+     * Valuta una singola condizione rispetto ai dati del form.
+     *
+     * @param condition - Condizione da valutare.
+     * @param formData - Stato corrente dei dati del form.
+     * @returns `true` se la condizione e soddisfatta.
+     */
+    evaluateCondition(condition, formData) {
+        const fieldValue = this.getNestedValue(formData, condition.field);
+        switch (condition.operator) {
+            case 'equals':
+                return fieldValue === condition.value;
+            case 'not_equals':
+                return fieldValue !== condition.value;
+            case 'contains':
+                return this.stringContains(fieldValue, condition.value);
+            case 'not_contains':
+                return !this.stringContains(fieldValue, condition.value);
+            case 'greater_than':
+                return this.numericCompare(fieldValue, condition.value, '>');
+            case 'less_than':
+                return this.numericCompare(fieldValue, condition.value, '<');
+            case 'greater_equal':
+                return this.numericCompare(fieldValue, condition.value, '>=');
+            case 'less_equal':
+                return this.numericCompare(fieldValue, condition.value, '<=');
+            case 'is_empty':
+                return this.isEmpty(fieldValue);
+            case 'is_not_empty':
+                return !this.isEmpty(fieldValue);
+            case 'in_array':
+                return Array.isArray(condition.value) && condition.value.includes(fieldValue);
+            case 'not_in_array':
+                return Array.isArray(condition.value) && !condition.value.includes(fieldValue);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Valuta un array di condizioni con logica AND/OR.
+     *
+     * La prima condizione stabilisce il valore iniziale.
+     * Le condizioni successive usano la proprieta `logic` per
+     * combinare il risultato (`AND` per default).
+     *
+     * @param conditions - Array di condizioni.
+     * @param formData - Stato corrente dei dati del form.
+     * @returns `true` se le condizioni combinate sono soddisfatte.
+     */
+    evaluateConditions(conditions, formData) {
+        if (!conditions || conditions.length === 0) {
+            return true;
+        }
+        let result = this.evaluateCondition(conditions[0], formData);
+        for (let i = 1; i < conditions.length; i++) {
+            const condition = conditions[i];
+            const conditionResult = this.evaluateCondition(condition, formData);
+            if (condition.logic === 'OR') {
+                result = result || conditionResult;
+            }
+            else {
+                result = result && conditionResult;
+            }
+        }
+        return result;
+    }
+    /** Accesso a valori annidati tramite dot notation (es. `'address.city'`). */
+    getNestedValue(obj, path) {
+        return path
+            .split('.')
+            .reduce((current, key) => (current != null && current[key] !== undefined ? current[key] : undefined), obj);
+    }
+    /** Confronto stringa case-insensitive. */
+    stringContains(haystack, needle) {
+        if (haystack == null || needle == null)
+            return false;
+        return String(haystack).toLowerCase().includes(String(needle).toLowerCase());
+    }
+    /** Confronto numerico generico. */
+    numericCompare(a, b, op) {
+        const n1 = Number(a);
+        const n2 = Number(b);
+        if (isNaN(n1) || isNaN(n2))
+            return false;
+        switch (op) {
+            case '>':
+                return n1 > n2;
+            case '<':
+                return n1 < n2;
+            case '>=':
+                return n1 >= n2;
+            case '<=':
+                return n1 <= n2;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Verifica se un valore e vuoto in modo robusto.
+     * Gestisce null, undefined, false, stringhe vuote, array vuoti e oggetti vuoti.
+     */
+    isEmpty(value) {
+        if (value === null || value === undefined || value === false)
+            return true;
+        if (typeof value === 'string' && value.trim().length === 0)
+            return true;
+        if (Array.isArray(value) && value.length === 0)
+            return true;
+        if (typeof value === 'object' && Object.keys(value).length === 0)
+            return true;
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormConditionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormConditionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormConditionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-condition.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/form-condition.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { UiFieldCondition } from '../types/condition.types';\r\n\r\n/**\r\n * Servizio per la valutazione delle condizioni di visibilita,\r\n * required e disable dei campi del form.\r\n *\r\n * Supporta 12 operatori di confronto, logica AND/OR\r\n * e accesso a valori annidati tramite dot notation.\r\n *\r\n * @providedIn 'root'\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiFormConditionService {\r\n  /**\r\n   * Valuta una singola condizione rispetto ai dati del form.\r\n   *\r\n   * @param condition - Condizione da valutare.\r\n   * @param formData - Stato corrente dei dati del form.\r\n   * @returns `true` se la condizione e soddisfatta.\r\n   */\r\n  evaluateCondition(condition: UiFieldCondition, formData: Record<string, any>): boolean {\r\n    const fieldValue = this.getNestedValue(formData, condition.field);\r\n\r\n    switch (condition.operator) {\r\n      case 'equals':\r\n        return fieldValue === condition.value;\r\n      case 'not_equals':\r\n        return fieldValue !== condition.value;\r\n      case 'contains':\r\n        return this.stringContains(fieldValue, condition.value);\r\n      case 'not_contains':\r\n        return !this.stringContains(fieldValue, condition.value);\r\n      case 'greater_than':\r\n        return this.numericCompare(fieldValue, condition.value, '>');\r\n      case 'less_than':\r\n        return this.numericCompare(fieldValue, condition.value, '<');\r\n      case 'greater_equal':\r\n        return this.numericCompare(fieldValue, condition.value, '>=');\r\n      case 'less_equal':\r\n        return this.numericCompare(fieldValue, condition.value, '<=');\r\n      case 'is_empty':\r\n        return this.isEmpty(fieldValue);\r\n      case 'is_not_empty':\r\n        return !this.isEmpty(fieldValue);\r\n      case 'in_array':\r\n        return Array.isArray(condition.value) && condition.value.includes(fieldValue);\r\n      case 'not_in_array':\r\n        return Array.isArray(condition.value) && !condition.value.includes(fieldValue);\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Valuta un array di condizioni con logica AND/OR.\r\n   *\r\n   * La prima condizione stabilisce il valore iniziale.\r\n   * Le condizioni successive usano la proprieta `logic` per\r\n   * combinare il risultato (`AND` per default).\r\n   *\r\n   * @param conditions - Array di condizioni.\r\n   * @param formData - Stato corrente dei dati del form.\r\n   * @returns `true` se le condizioni combinate sono soddisfatte.\r\n   */\r\n  evaluateConditions(conditions: UiFieldCondition[], formData: Record<string, any>): boolean {\r\n    if (!conditions || conditions.length === 0) {\r\n      return true;\r\n    }\r\n\r\n    let result = this.evaluateCondition(conditions[0], formData);\r\n\r\n    for (let i = 1; i < conditions.length; i++) {\r\n      const condition = conditions[i];\r\n      const conditionResult = this.evaluateCondition(condition, formData);\r\n\r\n      if (condition.logic === 'OR') {\r\n        result = result || conditionResult;\r\n      } else {\r\n        result = result && conditionResult;\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /** Accesso a valori annidati tramite dot notation (es. `'address.city'`). */\r\n  private getNestedValue(obj: any, path: string): any {\r\n    return path\r\n      .split('.')\r\n      .reduce((current, key) => (current != null && current[key] !== undefined ? current[key] : undefined), obj);\r\n  }\r\n\r\n  /** Confronto stringa case-insensitive. */\r\n  private stringContains(haystack: any, needle: any): boolean {\r\n    if (haystack == null || needle == null) return false;\r\n    return String(haystack).toLowerCase().includes(String(needle).toLowerCase());\r\n  }\r\n\r\n  /** Confronto numerico generico. */\r\n  private numericCompare(a: any, b: any, op: string): boolean {\r\n    const n1 = Number(a);\r\n    const n2 = Number(b);\r\n    if (isNaN(n1) || isNaN(n2)) return false;\r\n    switch (op) {\r\n      case '>':\r\n        return n1 > n2;\r\n      case '<':\r\n        return n1 < n2;\r\n      case '>=':\r\n        return n1 >= n2;\r\n      case '<=':\r\n        return n1 <= n2;\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Verifica se un valore e vuoto in modo robusto.\r\n   * Gestisce null, undefined, false, stringhe vuote, array vuoti e oggetti vuoti.\r\n   */\r\n  private isEmpty(value: any): boolean {\r\n    if (value === null || value === undefined || value === false) return true;\r\n    if (typeof value === 'string' && value.trim().length === 0) return true;\r\n    if (Array.isArray(value) && value.length === 0) return true;\r\n    if (typeof value === 'object' && Object.keys(value).length === 0) return true;\r\n    return false;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/form-builder/services/form-validation.service.mjs

@@ -0,0 +1,381 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { parse, format, startOfDay, startOfMonth, addDays, addMonths, addYears, addWeeks, isAfter, isBefore, isEqual, isValid as isDateValid, } from 'date-fns';
+import * as i0 from "@angular/core";
+import * as i1 from "./form-condition.service";
+/**
+ * Servizio per la creazione e gestione dei validatori Angular
+ * basati sulle regole dichiarative dello schema del form.
+ *
+ * Supporta validazioni standard, cross-field, date con offset,
+ * file e validatori condizionali.
+ *
+ * @providedIn 'root'
+ */
+export class UiFormValidationService {
+    constructor(conditionService) {
+        this.conditionService = conditionService;
+    }
+    // ─── Creazione validatori ──────────────────────────────────────
+    /** Crea un array di validatori Angular dalle regole di validazione. */
+    createValidators(rules) {
+        if (!rules?.length)
+            return [];
+        return rules.map((r) => this.createValidator(r)).filter((v) => v !== null);
+    }
+    /**
+     * Crea validatori con supporto condizionale.
+     * Le regole con `conditions` vengono applicate solo se le condizioni sono soddisfatte.
+     */
+    createConditionalValidators(rules, formData) {
+        if (!rules?.length)
+            return [];
+        const validators = [];
+        for (const rule of rules) {
+            if (rule.conditions?.length) {
+                const shouldApply = this.conditionService.evaluateConditions(rule.conditions, formData);
+                if (!shouldApply)
+                    continue;
+            }
+            const v = this.createValidator(rule);
+            if (v)
+                validators.push(v);
+        }
+        return validators;
+    }
+    /**
+     * Aggiorna i validatori di un campo in base allo stato corrente del form.
+     * Usato per ricalcolare validazioni condizionali quando i dati cambiano.
+     */
+    updateFieldValidators(control, rules, formData) {
+        if (!rules?.length) {
+            control.clearValidators();
+        }
+        else {
+            const validators = this.createConditionalValidators(rules, formData);
+            control.setValidators(validators);
+        }
+        control.updateValueAndValidity({ emitEvent: false });
+    }
+    // ─── Utility pubbliche ─────────────────────────────────────────
+    /** Verifica se un campo dovrebbe mostrare gli errori. */
+    shouldShowFieldErrors(control) {
+        return control.invalid && (control.dirty || control.touched);
+    }
+    /** Restituisce i campi correlati da cross-field validation. */
+    getCrossFieldRelatedFields(fieldKey, allRules) {
+        const related = [];
+        for (const [key, rules] of Object.entries(allRules)) {
+            if (key === fieldKey)
+                continue;
+            for (const rule of rules) {
+                if (rule.type === 'crossField' && rule.crossField?.targetField === fieldKey) {
+                    related.push(key);
+                }
+            }
+        }
+        return related;
+    }
+    /** Verifica se un campo ha validazioni cross-field che lo referenziano. */
+    hasCrossFieldValidations(fieldKey, allRules) {
+        return this.getCrossFieldRelatedFields(fieldKey, allRules).length > 0;
+    }
+    /** Formatta la dimensione del file in una stringa leggibile. */
+    formatFileSize(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    // ─── Factory validatori ────────────────────────────────────────
+    createValidator(rule) {
+        switch (rule.type) {
+            case 'required':
+                return Validators.required;
+            case 'email':
+                return Validators.email;
+            case 'min':
+                return Validators.min(rule.value);
+            case 'max':
+                return Validators.max(rule.value);
+            case 'minLength':
+                return Validators.minLength(rule.value);
+            case 'maxLength':
+                return Validators.maxLength(rule.value);
+            case 'pattern':
+                return Validators.pattern(rule.value);
+            case 'custom':
+                return rule.validator || null;
+            case 'crossField':
+                return rule.crossField ? this.createCrossFieldValidator(rule.crossField) : null;
+            case 'date-min':
+                return this.createDateMinValidator(rule.value, rule.offset);
+            case 'date-max':
+                return this.createDateMaxValidator(rule.value, rule.offset);
+            case 'fileSize':
+                return this.createFileSizeValidator(rule.value);
+            case 'fileType':
+                return this.createFileTypeValidator(rule.value);
+            case 'fileCount':
+                return this.createFileCountValidator(rule.value);
+            default:
+                return null;
+        }
+    }
+    // ─── Cross-field ───────────────────────────────────────────────
+    createCrossFieldValidator(config) {
+        return (control) => {
+            if (!control.parent || !config.targetField)
+                return null;
+            const targetControl = control.parent.get(config.targetField);
+            if (!targetControl)
+                return null;
+            const sourceValue = control.value;
+            const targetValue = targetControl.value;
+            if (sourceValue == null || targetValue == null || sourceValue === '' || targetValue === '') {
+                return null;
+            }
+            let isValid = false;
+            if (config.dataType === 'date') {
+                isValid = this.validateDateComparison(sourceValue, targetValue, config.operator, config.isMonthYear);
+            }
+            else {
+                isValid = this.validateNumberComparison(sourceValue, targetValue, config.operator);
+            }
+            return isValid
+                ? null
+                : {
+                    crossField: {
+                        actualValue: sourceValue,
+                        requiredComparison: config.operator,
+                        comparedValue: targetValue,
+                        targetField: config.targetField,
+                    },
+                };
+        };
+    }
+    /** Confronto date con date-fns. */
+    validateDateComparison(sourceValue, targetValue, operator, isMonthYear) {
+        const normalize = isMonthYear ? startOfMonth : startOfDay;
+        const sourceDate = normalize(new Date(sourceValue));
+        const targetDate = normalize(new Date(targetValue));
+        if (!isDateValid(sourceDate) || !isDateValid(targetDate))
+            return false;
+        switch (operator) {
+            case 'greater_than':
+                return isAfter(sourceDate, targetDate);
+            case 'greater_equal':
+                return isAfter(sourceDate, targetDate) || isEqual(sourceDate, targetDate);
+            case 'less_than':
+                return isBefore(sourceDate, targetDate);
+            case 'less_equal':
+                return isBefore(sourceDate, targetDate) || isEqual(sourceDate, targetDate);
+            case 'not_equal':
+                return !isEqual(sourceDate, targetDate);
+            default:
+                return false;
+        }
+    }
+    /** Confronto numerico. */
+    validateNumberComparison(sourceValue, targetValue, operator) {
+        const src = Number(sourceValue);
+        const tgt = Number(targetValue);
+        if (isNaN(src) || isNaN(tgt))
+            return false;
+        switch (operator) {
+            case 'greater_than':
+                return src > tgt;
+            case 'greater_equal':
+                return src >= tgt;
+            case 'less_than':
+                return src < tgt;
+            case 'less_equal':
+                return src <= tgt;
+            case 'not_equal':
+                return src !== tgt;
+            default:
+                return false;
+        }
+    }
+    // ─── Date min/max (con keyword e offset) ───────────────────────
+    createDateMinValidator(value, offset) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const refDate = this.parseReferenceDate(value, offset);
+            if (!refDate)
+                return null;
+            const inputDate = startOfDay(new Date(control.value));
+            if (!isDateValid(inputDate)) {
+                return { 'date-min': { message: 'Data non valida', referenceDate: this.formatRefDate(refDate) } };
+            }
+            if (isBefore(inputDate, refDate)) {
+                return {
+                    'date-min': {
+                        message: `La data deve essere successiva o uguale a ${this.formatRefDate(refDate)}`,
+                        referenceDate: this.formatRefDate(refDate),
+                        inputDate: format(inputDate, 'dd/MM/yyyy'),
+                    },
+                };
+            }
+            return null;
+        };
+    }
+    createDateMaxValidator(value, offset) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const refDate = this.parseReferenceDate(value, offset);
+            if (!refDate)
+                return null;
+            const inputDate = startOfDay(new Date(control.value));
+            if (!isDateValid(inputDate)) {
+                return { 'date-max': { message: 'Data non valida', referenceDate: this.formatRefDate(refDate) } };
+            }
+            if (isAfter(inputDate, refDate)) {
+                return {
+                    'date-max': {
+                        message: `La data deve essere precedente o uguale a ${this.formatRefDate(refDate)}`,
+                        referenceDate: this.formatRefDate(refDate),
+                        inputDate: format(inputDate, 'dd/MM/yyyy'),
+                    },
+                };
+            }
+            return null;
+        };
+    }
+    /**
+     * Parsa una data di riferimento da keyword o stringa DD/MM/YYYY
+     * e applica un eventuale offset temporale.
+     */
+    parseReferenceDate(value, offset) {
+        const today = startOfDay(new Date());
+        let date;
+        switch (value?.toLowerCase().trim()) {
+            case 'today':
+            case 'oggi':
+                date = today;
+                break;
+            case 'tomorrow':
+            case 'domani':
+                date = addDays(today, 1);
+                break;
+            case 'yesterday':
+            case 'ieri':
+                date = addDays(today, -1);
+                break;
+            default: {
+                // Prova DD/MM/YYYY
+                const parsed = parse(value, 'dd/MM/yyyy', new Date());
+                if (isDateValid(parsed)) {
+                    date = startOfDay(parsed);
+                }
+                else {
+                    // Prova YYYY-MM-DD (ISO)
+                    const isoDate = new Date(value);
+                    if (isDateValid(isoDate)) {
+                        date = startOfDay(isoDate);
+                    }
+                    else {
+                        return null;
+                    }
+                }
+            }
+        }
+        return offset ? this.applyDateOffset(date, offset) : date;
+    }
+    /**
+     * Applica un offset temporale a una data.
+     *
+     * Formato: `numero + unita`
+     * - `y`/`a` = anni, `m` = mesi, `g`/`d` = giorni, `s`/`w` = settimane
+     */
+    applyDateOffset(date, offset) {
+        const match = offset.match(/^(-?\d+)([yYaAmMgGdDsSwW])$/);
+        if (!match)
+            return date;
+        const amount = parseInt(match[1], 10);
+        switch (match[2].toLowerCase()) {
+            case 'y':
+            case 'a':
+                return addYears(date, amount);
+            case 'm':
+                return addMonths(date, amount);
+            case 'g':
+            case 'd':
+                return addDays(date, amount);
+            case 's':
+            case 'w':
+                return addWeeks(date, amount);
+            default:
+                return date;
+        }
+    }
+    formatRefDate(date) {
+        return format(date, 'dd/MM/yyyy');
+    }
+    // ─── File validators ───────────────────────────────────────────
+    createFileSizeValidator(maxSize) {
+        return (control) => {
+            const files = control.value;
+            if (!Array.isArray(files) || files.length === 0)
+                return null;
+            const oversized = files.filter((f) => f.size > maxSize);
+            if (oversized.length > 0) {
+                return {
+                    fileSize: {
+                        maxSize,
+                        maxSizeFormatted: this.formatFileSize(maxSize),
+                        files: oversized.map((f) => f.filename),
+                    },
+                };
+            }
+            return null;
+        };
+    }
+    createFileTypeValidator(allowedTypes) {
+        return (control) => {
+            const files = control.value;
+            if (!Array.isArray(files) || files.length === 0)
+                return null;
+            const invalid = files.filter((f) => {
+                return !allowedTypes.some((type) => {
+                    if (type.endsWith('/*')) {
+                        const category = type.split('/')[0];
+                        return f.mimeType.startsWith(category + '/');
+                    }
+                    return f.mimeType === type;
+                });
+            });
+            if (invalid.length > 0) {
+                return {
+                    fileType: {
+                        allowedTypes,
+                        files: invalid.map((f) => f.filename),
+                    },
+                };
+            }
+            return null;
+        };
+    }
+    createFileCountValidator(maxCount) {
+        return (control) => {
+            const files = control.value;
+            if (!Array.isArray(files))
+                return null;
+            if (files.length > maxCount) {
+                return { fileCount: { maxCount, actualCount: files.length } };
+            }
+            return null;
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormValidationService, deps: [{ token: i1.UiFormConditionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormValidationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormValidationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.UiFormConditionService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-validation.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/form-validation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { AbstractControl, ValidatorFn, Validators } from '@angular/forms';\r\nimport {\r\n  parse,\r\n  format,\r\n  startOfDay,\r\n  startOfMonth,\r\n  addDays,\r\n  addMonths,\r\n  addYears,\r\n  addWeeks,\r\n  isAfter,\r\n  isBefore,\r\n  isEqual,\r\n  isValid as isDateValid,\r\n} from 'date-fns';\r\nimport { UiValidationRule } from '../types/validation.types';\r\nimport { UiCrossFieldConfig, UiCrossFieldOperator } from '../types/validation.types';\r\nimport { UiFileData } from '../types/field.types';\r\nimport { UiFormConditionService } from './form-condition.service';\r\n\r\n/**\r\n * Servizio per la creazione e gestione dei validatori Angular\r\n * basati sulle regole dichiarative dello schema del form.\r\n *\r\n * Supporta validazioni standard, cross-field, date con offset,\r\n * file e validatori condizionali.\r\n *\r\n * @providedIn 'root'\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiFormValidationService {\r\n  constructor(private conditionService: UiFormConditionService) {}\r\n\r\n  // ─── Creazione validatori ──────────────────────────────────────\r\n\r\n  /** Crea un array di validatori Angular dalle regole di validazione. */\r\n  createValidators(rules: UiValidationRule[]): ValidatorFn[] {\r\n    if (!rules?.length) return [];\r\n    return rules.map((r) => this.createValidator(r)).filter((v): v is ValidatorFn => v !== null);\r\n  }\r\n\r\n  /**\r\n   * Crea validatori con supporto condizionale.\r\n   * Le regole con `conditions` vengono applicate solo se le condizioni sono soddisfatte.\r\n   */\r\n  createConditionalValidators(rules: UiValidationRule[], formData: Record<string, any>): ValidatorFn[] {\r\n    if (!rules?.length) return [];\r\n    const validators: ValidatorFn[] = [];\r\n\r\n    for (const rule of rules) {\r\n      if (rule.conditions?.length) {\r\n        const shouldApply = this.conditionService.evaluateConditions(rule.conditions, formData);\r\n        if (!shouldApply) continue;\r\n      }\r\n      const v = this.createValidator(rule);\r\n      if (v) validators.push(v);\r\n    }\r\n\r\n    return validators;\r\n  }\r\n\r\n  /**\r\n   * Aggiorna i validatori di un campo in base allo stato corrente del form.\r\n   * Usato per ricalcolare validazioni condizionali quando i dati cambiano.\r\n   */\r\n  updateFieldValidators(\r\n    control: AbstractControl,\r\n    rules: UiValidationRule[] | undefined,\r\n    formData: Record<string, any>,\r\n  ): void {\r\n    if (!rules?.length) {\r\n      control.clearValidators();\r\n    } else {\r\n      const validators = this.createConditionalValidators(rules, formData);\r\n      control.setValidators(validators);\r\n    }\r\n    control.updateValueAndValidity({ emitEvent: false });\r\n  }\r\n\r\n  // ─── Utility pubbliche ─────────────────────────────────────────\r\n\r\n  /** Verifica se un campo dovrebbe mostrare gli errori. */\r\n  shouldShowFieldErrors(control: AbstractControl): boolean {\r\n    return control.invalid && (control.dirty || control.touched);\r\n  }\r\n\r\n  /** Restituisce i campi correlati da cross-field validation. */\r\n  getCrossFieldRelatedFields(fieldKey: string, allRules: Record<string, UiValidationRule[]>): string[] {\r\n    const related: string[] = [];\r\n    for (const [key, rules] of Object.entries(allRules)) {\r\n      if (key === fieldKey) continue;\r\n      for (const rule of rules) {\r\n        if (rule.type === 'crossField' && rule.crossField?.targetField === fieldKey) {\r\n          related.push(key);\r\n        }\r\n      }\r\n    }\r\n    return related;\r\n  }\r\n\r\n  /** Verifica se un campo ha validazioni cross-field che lo referenziano. */\r\n  hasCrossFieldValidations(fieldKey: string, allRules: Record<string, UiValidationRule[]>): boolean {\r\n    return this.getCrossFieldRelatedFields(fieldKey, allRules).length > 0;\r\n  }\r\n\r\n  /** Formatta la dimensione del file in una stringa leggibile. */\r\n  formatFileSize(bytes: number): string {\r\n    if (bytes === 0) return '0 B';\r\n    const k = 1024;\r\n    const sizes = ['B', 'KB', 'MB', 'GB'];\r\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\r\n    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];\r\n  }\r\n\r\n  // ─── Factory validatori ────────────────────────────────────────\r\n\r\n  private createValidator(rule: UiValidationRule): ValidatorFn | null {\r\n    switch (rule.type) {\r\n      case 'required':\r\n        return Validators.required;\r\n      case 'email':\r\n        return Validators.email;\r\n      case 'min':\r\n        return Validators.min(rule.value);\r\n      case 'max':\r\n        return Validators.max(rule.value);\r\n      case 'minLength':\r\n        return Validators.minLength(rule.value);\r\n      case 'maxLength':\r\n        return Validators.maxLength(rule.value);\r\n      case 'pattern':\r\n        return Validators.pattern(rule.value);\r\n      case 'custom':\r\n        return rule.validator || null;\r\n      case 'crossField':\r\n        return rule.crossField ? this.createCrossFieldValidator(rule.crossField) : null;\r\n      case 'date-min':\r\n        return this.createDateMinValidator(rule.value, rule.offset);\r\n      case 'date-max':\r\n        return this.createDateMaxValidator(rule.value, rule.offset);\r\n      case 'fileSize':\r\n        return this.createFileSizeValidator(rule.value);\r\n      case 'fileType':\r\n        return this.createFileTypeValidator(rule.value);\r\n      case 'fileCount':\r\n        return this.createFileCountValidator(rule.value);\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  // ─── Cross-field ───────────────────────────────────────────────\r\n\r\n  private createCrossFieldValidator(config: UiCrossFieldConfig): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      if (!control.parent || !config.targetField) return null;\r\n\r\n      const targetControl = control.parent.get(config.targetField);\r\n      if (!targetControl) return null;\r\n\r\n      const sourceValue = control.value;\r\n      const targetValue = targetControl.value;\r\n\r\n      if (sourceValue == null || targetValue == null || sourceValue === '' || targetValue === '') {\r\n        return null;\r\n      }\r\n\r\n      let isValid = false;\r\n      if (config.dataType === 'date') {\r\n        isValid = this.validateDateComparison(sourceValue, targetValue, config.operator, config.isMonthYear);\r\n      } else {\r\n        isValid = this.validateNumberComparison(sourceValue, targetValue, config.operator);\r\n      }\r\n\r\n      return isValid\r\n        ? null\r\n        : {\r\n            crossField: {\r\n              actualValue: sourceValue,\r\n              requiredComparison: config.operator,\r\n              comparedValue: targetValue,\r\n              targetField: config.targetField,\r\n            },\r\n          };\r\n    };\r\n  }\r\n\r\n  /** Confronto date con date-fns. */\r\n  private validateDateComparison(\r\n    sourceValue: any,\r\n    targetValue: any,\r\n    operator: UiCrossFieldOperator,\r\n    isMonthYear?: boolean,\r\n  ): boolean {\r\n    const normalize = isMonthYear ? startOfMonth : startOfDay;\r\n    const sourceDate = normalize(new Date(sourceValue));\r\n    const targetDate = normalize(new Date(targetValue));\r\n\r\n    if (!isDateValid(sourceDate) || !isDateValid(targetDate)) return false;\r\n\r\n    switch (operator) {\r\n      case 'greater_than':\r\n        return isAfter(sourceDate, targetDate);\r\n      case 'greater_equal':\r\n        return isAfter(sourceDate, targetDate) || isEqual(sourceDate, targetDate);\r\n      case 'less_than':\r\n        return isBefore(sourceDate, targetDate);\r\n      case 'less_equal':\r\n        return isBefore(sourceDate, targetDate) || isEqual(sourceDate, targetDate);\r\n      case 'not_equal':\r\n        return !isEqual(sourceDate, targetDate);\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  /** Confronto numerico. */\r\n  private validateNumberComparison(sourceValue: any, targetValue: any, operator: UiCrossFieldOperator): boolean {\r\n    const src = Number(sourceValue);\r\n    const tgt = Number(targetValue);\r\n    if (isNaN(src) || isNaN(tgt)) return false;\r\n\r\n    switch (operator) {\r\n      case 'greater_than':\r\n        return src > tgt;\r\n      case 'greater_equal':\r\n        return src >= tgt;\r\n      case 'less_than':\r\n        return src < tgt;\r\n      case 'less_equal':\r\n        return src <= tgt;\r\n      case 'not_equal':\r\n        return src !== tgt;\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  // ─── Date min/max (con keyword e offset) ───────────────────────\r\n\r\n  private createDateMinValidator(value: string, offset?: string): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      if (!control.value) return null;\r\n\r\n      const refDate = this.parseReferenceDate(value, offset);\r\n      if (!refDate) return null;\r\n\r\n      const inputDate = startOfDay(new Date(control.value));\r\n      if (!isDateValid(inputDate)) {\r\n        return { 'date-min': { message: 'Data non valida', referenceDate: this.formatRefDate(refDate) } };\r\n      }\r\n\r\n      if (isBefore(inputDate, refDate)) {\r\n        return {\r\n          'date-min': {\r\n            message: `La data deve essere successiva o uguale a ${this.formatRefDate(refDate)}`,\r\n            referenceDate: this.formatRefDate(refDate),\r\n            inputDate: format(inputDate, 'dd/MM/yyyy'),\r\n          },\r\n        };\r\n      }\r\n      return null;\r\n    };\r\n  }\r\n\r\n  private createDateMaxValidator(value: string, offset?: string): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      if (!control.value) return null;\r\n\r\n      const refDate = this.parseReferenceDate(value, offset);\r\n      if (!refDate) return null;\r\n\r\n      const inputDate = startOfDay(new Date(control.value));\r\n      if (!isDateValid(inputDate)) {\r\n        return { 'date-max': { message: 'Data non valida', referenceDate: this.formatRefDate(refDate) } };\r\n      }\r\n\r\n      if (isAfter(inputDate, refDate)) {\r\n        return {\r\n          'date-max': {\r\n            message: `La data deve essere precedente o uguale a ${this.formatRefDate(refDate)}`,\r\n            referenceDate: this.formatRefDate(refDate),\r\n            inputDate: format(inputDate, 'dd/MM/yyyy'),\r\n          },\r\n        };\r\n      }\r\n      return null;\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Parsa una data di riferimento da keyword o stringa DD/MM/YYYY\r\n   * e applica un eventuale offset temporale.\r\n   */\r\n  private parseReferenceDate(value: string, offset?: string): Date | null {\r\n    const today = startOfDay(new Date());\r\n    let date: Date;\r\n\r\n    switch (value?.toLowerCase().trim()) {\r\n      case 'today':\r\n      case 'oggi':\r\n        date = today;\r\n        break;\r\n      case 'tomorrow':\r\n      case 'domani':\r\n        date = addDays(today, 1);\r\n        break;\r\n      case 'yesterday':\r\n      case 'ieri':\r\n        date = addDays(today, -1);\r\n        break;\r\n      default: {\r\n        // Prova DD/MM/YYYY\r\n        const parsed = parse(value, 'dd/MM/yyyy', new Date());\r\n        if (isDateValid(parsed)) {\r\n          date = startOfDay(parsed);\r\n        } else {\r\n          // Prova YYYY-MM-DD (ISO)\r\n          const isoDate = new Date(value);\r\n          if (isDateValid(isoDate)) {\r\n            date = startOfDay(isoDate);\r\n          } else {\r\n            return null;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return offset ? this.applyDateOffset(date, offset) : date;\r\n  }\r\n\r\n  /**\r\n   * Applica un offset temporale a una data.\r\n   *\r\n   * Formato: `numero + unita`\r\n   * - `y`/`a` = anni, `m` = mesi, `g`/`d` = giorni, `s`/`w` = settimane\r\n   */\r\n  private applyDateOffset(date: Date, offset: string): Date {\r\n    const match = offset.match(/^(-?\\d+)([yYaAmMgGdDsSwW])$/);\r\n    if (!match) return date;\r\n\r\n    const amount = parseInt(match[1], 10);\r\n    switch (match[2].toLowerCase()) {\r\n      case 'y':\r\n      case 'a':\r\n        return addYears(date, amount);\r\n      case 'm':\r\n        return addMonths(date, amount);\r\n      case 'g':\r\n      case 'd':\r\n        return addDays(date, amount);\r\n      case 's':\r\n      case 'w':\r\n        return addWeeks(date, amount);\r\n      default:\r\n        return date;\r\n    }\r\n  }\r\n\r\n  private formatRefDate(date: Date): string {\r\n    return format(date, 'dd/MM/yyyy');\r\n  }\r\n\r\n  // ─── File validators ───────────────────────────────────────────\r\n\r\n  private createFileSizeValidator(maxSize: number): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      const files: UiFileData[] = control.value;\r\n      if (!Array.isArray(files) || files.length === 0) return null;\r\n\r\n      const oversized = files.filter((f) => f.size > maxSize);\r\n      if (oversized.length > 0) {\r\n        return {\r\n          fileSize: {\r\n            maxSize,\r\n            maxSizeFormatted: this.formatFileSize(maxSize),\r\n            files: oversized.map((f) => f.filename),\r\n          },\r\n        };\r\n      }\r\n      return null;\r\n    };\r\n  }\r\n\r\n  private createFileTypeValidator(allowedTypes: string[]): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      const files: UiFileData[] = control.value;\r\n      if (!Array.isArray(files) || files.length === 0) return null;\r\n\r\n      const invalid = files.filter((f) => {\r\n        return !allowedTypes.some((type) => {\r\n          if (type.endsWith('/*')) {\r\n            const category = type.split('/')[0];\r\n            return f.mimeType.startsWith(category + '/');\r\n          }\r\n          return f.mimeType === type;\r\n        });\r\n      });\r\n\r\n      if (invalid.length > 0) {\r\n        return {\r\n          fileType: {\r\n            allowedTypes,\r\n            files: invalid.map((f) => f.filename),\r\n          },\r\n        };\r\n      }\r\n      return null;\r\n    };\r\n  }\r\n\r\n  private createFileCountValidator(maxCount: number): ValidatorFn {\r\n    return (control: AbstractControl) => {\r\n      const files: UiFileData[] = control.value;\r\n      if (!Array.isArray(files)) return null;\r\n\r\n      if (files.length > maxCount) {\r\n        return { fileCount: { maxCount, actualCount: files.length } };\r\n      }\r\n      return null;\r\n    };\r\n  }\r\n}\r\n"]}