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

package/esm2022/form-builder-editor/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"]}

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

@@ -0,0 +1,141 @@
+import { Injectable } from '@angular/core';
+import * as locationData from '../../../sources/location-data.opt.json';
+import * as nazioniData from '../../../sources/nazioni.opt.json';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per la gestione dei dati geografici italiani
+ * da file JSON statici ottimizzati.
+ *
+ * Elimina la necessita di chiamate backend per nazioni,
+ * province, comuni e CAP. I dati vengono caricati in memoria
+ * al primo accesso e poi serviti dalla cache.
+ *
+ * @providedIn 'root'
+ *
+ * @example
+ * ```typescript
+ * const nazioni = await this.locationService.getNazioni();
+ * const province = await this.locationService.getProvince();
+ * const comuni = await this.locationService.getComuniByProvincia('015');
+ * const caps = await this.locationService.getCapList('015146');
+ * ```
+ */
+export class UiLocationService {
+    constructor() {
+        this.nazioniCache = new Map();
+        this.provinceCache = new Map();
+        this.comuniCache = new Map();
+        this.nazioniMap = nazioniData;
+        this.locationMap = locationData;
+        this.initializeCaches();
+    }
+    // ─── API pubblica ──────────────────────────────────────────────
+    /** Elenco completo delle nazioni (Italia prima). */
+    async getNazioni() {
+        const nazioni = Array.from(this.nazioniCache.values());
+        return { data: this.sortNazioniItaliaFirst(nazioni) };
+    }
+    /** Elenco completo delle province, ordinate alfabeticamente. */
+    async getProvince() {
+        const province = Array.from(this.provinceCache.values()).sort((a, b) => a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'));
+        return { content: province };
+    }
+    /** Elenco dei comuni per una specifica provincia. */
+    async getComuniByProvincia(provinciaId) {
+        const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];
+        const provincia = this.provinceCache.get(provinciaId);
+        if (!provincia)
+            return [];
+        return comuniMin
+            .map((c) => ({
+            codiceCatastale: c.x,
+            codiceComunePk: c.x,
+            comuneSoppresso: false,
+            nomeComune: c.d,
+            prov: provincia,
+            visibile: true,
+        }))
+            .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));
+    }
+    /** Elenco dei CAP per un comune. */
+    async getCapList(comuneId) {
+        for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {
+            const comune = comuni.find((c) => c.x === comuneId);
+            if (comune?.c) {
+                return Array.isArray(comune.c) ? comune.c : [comune.c];
+            }
+        }
+        return [];
+    }
+    /** Dati completi di una location (nazione, provincia o comune). */
+    async getLocationFullData(type, id, provinciaId) {
+        switch (type) {
+            case 'nazione':
+                return this.nazioniCache.get(id) ?? null;
+            case 'provincia':
+                return this.provinceCache.get(id) ?? null;
+            case 'comune': {
+                if (!provinciaId)
+                    return this.comuniCache.get(id) ?? null;
+                const comuni = await this.getComuniByProvincia(provinciaId);
+                return comuni.find((c) => c.codiceComunePk === id) ?? null;
+            }
+            default:
+                return null;
+        }
+    }
+    // ─── Inizializzazione cache ────────────────────────────────────
+    initializeCaches() {
+        // Nazioni
+        for (const n of this.nazioniMap.nazioni) {
+            this.nazioniCache.set(n.x, {
+                codStatoPk: n.x,
+                codiceCatastale: n.x,
+                descrizione: n.d,
+            });
+        }
+        // Province
+        for (const p of this.locationMap.province) {
+            this.provinceCache.set(p.x, {
+                codiceProvinciaPk: p.x,
+                nomeProvincia: p.d,
+                siglaProvincia: p.x,
+                visibile: true,
+            });
+        }
+        // Comuni (con riferimento alla provincia)
+        for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {
+            const provincia = this.provinceCache.get(provinciaId);
+            if (!provincia)
+                continue;
+            for (const c of comuni) {
+                this.comuniCache.set(c.x, {
+                    codiceCatastale: c.x,
+                    codiceComunePk: c.x,
+                    comuneSoppresso: false,
+                    nomeComune: c.d,
+                    prov: provincia,
+                    visibile: true,
+                });
+            }
+        }
+    }
+    sortNazioniItaliaFirst(nazioni) {
+        return nazioni.sort((a, b) => {
+            const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';
+            const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';
+            if (aItalia && !bItalia)
+                return -1;
+            if (!aItalia && bItalia)
+                return 1;
+            return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiLocationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.service.js","sourceRoot":"","sources":["../../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/location.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as locationData from '../../../sources/location-data.opt.json';\r\nimport * as nazioniData from '../../../sources/nazioni.opt.json';\r\n\r\n// ─── Interfacce JSON ottimizzate ──────────────────────────────────\r\n\r\n/** Voce nazione nel JSON ottimizzato. */\r\nexport interface MinifiedNazioneOption {\r\n  /** Codice nazione (es. `'ITA'`). */\r\n  x: string;\r\n  /** Descrizione (es. `'Italia'`). */\r\n  d: string;\r\n}\r\n\r\n/** Voce provincia/comune nel JSON ottimizzato. */\r\nexport interface MinifiedSelectOption {\r\n  /** Codice (provincia o comune). */\r\n  x: string;\r\n  /** Descrizione. */\r\n  d: string;\r\n  /** CAP singolo o multipli. */\r\n  c?: string | string[];\r\n}\r\n\r\ninterface MinifiedLocationMap {\r\n  province: MinifiedSelectOption[];\r\n  comuniPerProvincia: Record<string, MinifiedSelectOption[]>;\r\n}\r\n\r\ninterface MinifiedNazioniMap {\r\n  nazioni: MinifiedNazioneOption[];\r\n}\r\n\r\n// ─── Interfacce pubbliche (formato legacy compatibile) ───────────\r\n\r\n/** Nazione. */\r\nexport interface UiNazione {\r\n  codStatoPk: string;\r\n  codiceCatastale: string;\r\n  descrizione: string;\r\n}\r\n\r\n/** Provincia. */\r\nexport interface UiProvincia {\r\n  codiceProvinciaPk: string;\r\n  nomeProvincia: string;\r\n  siglaProvincia: string;\r\n  visibile: boolean;\r\n}\r\n\r\n/** Comune. */\r\nexport interface UiComune {\r\n  codiceCatastale: string;\r\n  codiceComunePk: string;\r\n  comuneSoppresso: boolean;\r\n  nomeComune: string;\r\n  prov: UiProvincia;\r\n  visibile: boolean;\r\n}\r\n\r\n/**\r\n * Servizio per la gestione dei dati geografici italiani\r\n * da file JSON statici ottimizzati.\r\n *\r\n * Elimina la necessita di chiamate backend per nazioni,\r\n * province, comuni e CAP. I dati vengono caricati in memoria\r\n * al primo accesso e poi serviti dalla cache.\r\n *\r\n * @providedIn 'root'\r\n *\r\n * @example\r\n * ```typescript\r\n * const nazioni = await this.locationService.getNazioni();\r\n * const province = await this.locationService.getProvince();\r\n * const comuni = await this.locationService.getComuniByProvincia('015');\r\n * const caps = await this.locationService.getCapList('015146');\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiLocationService {\r\n  private readonly nazioniMap: MinifiedNazioniMap;\r\n  private readonly locationMap: MinifiedLocationMap;\r\n  private readonly nazioniCache = new Map<string, UiNazione>();\r\n  private readonly provinceCache = new Map<string, UiProvincia>();\r\n  private readonly comuniCache = new Map<string, UiComune>();\r\n\r\n  constructor() {\r\n    this.nazioniMap = nazioniData as MinifiedNazioniMap;\r\n    this.locationMap = locationData as any;\r\n    this.initializeCaches();\r\n  }\r\n\r\n  // ─── API pubblica ──────────────────────────────────────────────\r\n\r\n  /** Elenco completo delle nazioni (Italia prima). */\r\n  async getNazioni(): Promise<{ data: UiNazione[] }> {\r\n    const nazioni = Array.from(this.nazioniCache.values());\r\n    return { data: this.sortNazioniItaliaFirst(nazioni) };\r\n  }\r\n\r\n  /** Elenco completo delle province, ordinate alfabeticamente. */\r\n  async getProvince(): Promise<{ content: UiProvincia[] }> {\r\n    const province = Array.from(this.provinceCache.values()).sort((a, b) =>\r\n      a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'),\r\n    );\r\n    return { content: province };\r\n  }\r\n\r\n  /** Elenco dei comuni per una specifica provincia. */\r\n  async getComuniByProvincia(provinciaId: string): Promise<UiComune[]> {\r\n    const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];\r\n    const provincia = this.provinceCache.get(provinciaId);\r\n    if (!provincia) return [];\r\n\r\n    return comuniMin\r\n      .map((c) => ({\r\n        codiceCatastale: c.x,\r\n        codiceComunePk: c.x,\r\n        comuneSoppresso: false,\r\n        nomeComune: c.d,\r\n        prov: provincia,\r\n        visibile: true,\r\n      }))\r\n      .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));\r\n  }\r\n\r\n  /** Elenco dei CAP per un comune. */\r\n  async getCapList(comuneId: string): Promise<string[]> {\r\n    for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {\r\n      const comune = comuni.find((c) => c.x === comuneId);\r\n      if (comune?.c) {\r\n        return Array.isArray(comune.c) ? comune.c : [comune.c];\r\n      }\r\n    }\r\n    return [];\r\n  }\r\n\r\n  /** Dati completi di una location (nazione, provincia o comune). */\r\n  async getLocationFullData(\r\n    type: 'nazione' | 'provincia' | 'comune',\r\n    id: string,\r\n    provinciaId?: string,\r\n  ): Promise<UiNazione | UiProvincia | UiComune | null> {\r\n    switch (type) {\r\n      case 'nazione':\r\n        return this.nazioniCache.get(id) ?? null;\r\n      case 'provincia':\r\n        return this.provinceCache.get(id) ?? null;\r\n      case 'comune': {\r\n        if (!provinciaId) return this.comuniCache.get(id) ?? null;\r\n        const comuni = await this.getComuniByProvincia(provinciaId);\r\n        return comuni.find((c) => c.codiceComunePk === id) ?? null;\r\n      }\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  // ─── Inizializzazione cache ────────────────────────────────────\r\n\r\n  private initializeCaches(): void {\r\n    // Nazioni\r\n    for (const n of this.nazioniMap.nazioni) {\r\n      this.nazioniCache.set(n.x, {\r\n        codStatoPk: n.x,\r\n        codiceCatastale: n.x,\r\n        descrizione: n.d,\r\n      });\r\n    }\r\n\r\n    // Province\r\n    for (const p of this.locationMap.province) {\r\n      this.provinceCache.set(p.x, {\r\n        codiceProvinciaPk: p.x,\r\n        nomeProvincia: p.d,\r\n        siglaProvincia: p.x,\r\n        visibile: true,\r\n      });\r\n    }\r\n\r\n    // Comuni (con riferimento alla provincia)\r\n    for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {\r\n      const provincia = this.provinceCache.get(provinciaId);\r\n      if (!provincia) continue;\r\n      for (const c of comuni) {\r\n        this.comuniCache.set(c.x, {\r\n          codiceCatastale: c.x,\r\n          codiceComunePk: c.x,\r\n          comuneSoppresso: false,\r\n          nomeComune: c.d,\r\n          prov: provincia,\r\n          visibile: true,\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private sortNazioniItaliaFirst(nazioni: UiNazione[]): UiNazione[] {\r\n    return nazioni.sort((a, b) => {\r\n      const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';\r\n      const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';\r\n      if (aItalia && !bItalia) return -1;\r\n      if (!aItalia && bItalia) return 1;\r\n      return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });\r\n    });\r\n  }\r\n}\r\n"]}