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

package/esm2022/crud-table/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/crud-table/lib/components/form-builder/services/form-error-state.matcher.mjs

@@ -0,0 +1,10 @@
+/**
+ * ErrorStateMatcher condiviso tra form-builder e campi atomici.
+ * Mostra errore quando il controllo è invalido e (touched o dirty).
+ */
+export class UiFormErrorStateMatcher {
+    isErrorState(control, _form) {
+        return !!(control && control.invalid && (control.touched || control.dirty));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1lcnJvci1zdGF0ZS5tYXRjaGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctdWktc3lzdGVtL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWJ1aWxkZXIvc2VydmljZXMvZm9ybS1lcnJvci1zdGF0ZS5tYXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7R0FHRztBQUNILE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsWUFBWSxDQUFDLE9BQTJCLEVBQUUsS0FBeUM7UUFDakYsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDOUUsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUNvbnRyb2wsIEZvcm1Hcm91cERpcmVjdGl2ZSwgTmdGb3JtIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBFcnJvclN0YXRlTWF0Y2hlciB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIEVycm9yU3RhdGVNYXRjaGVyIGNvbmRpdmlzbyB0cmEgZm9ybS1idWlsZGVyIGUgY2FtcGkgYXRvbWljaS5cclxuICogTW9zdHJhIGVycm9yZSBxdWFuZG8gaWwgY29udHJvbGxvIMOoIGludmFsaWRvIGUgKHRvdWNoZWQgbyBkaXJ0eSkuXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgVWlGb3JtRXJyb3JTdGF0ZU1hdGNoZXIgaW1wbGVtZW50cyBFcnJvclN0YXRlTWF0Y2hlciB7XHJcbiAgaXNFcnJvclN0YXRlKGNvbnRyb2w6IEZvcm1Db250cm9sIHwgbnVsbCwgX2Zvcm06IEZvcm1Hcm91cERpcmVjdGl2ZSB8IE5nRm9ybSB8IG51bGwpOiBib29sZWFuIHtcclxuICAgIHJldHVybiAhIShjb250cm9sICYmIGNvbnRyb2wuaW52YWxpZCAmJiAoY29udHJvbC50b3VjaGVkIHx8IGNvbnRyb2wuZGlydHkpKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/crud-table/lib/components/form-builder/services/form-field-error.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servizio condiviso per messaggi di errore, visibilità errori e conteggio caratteri
+ * dei campi form-builder e dei componenti atomici standalone.
+ */
+export class UiFormFieldErrorService {
+    /**
+     * Restituisce i messaggi di errore user-facing per un controllo.
+     *
+     * @param control Controllo Angular del campo
+     * @param rules Regole di validazione dichiarative (messaggi custom dallo schema)
+     */
+    getFieldErrors(control, rules = []) {
+        if (!control?.errors)
+            return [];
+        const messages = [];
+        for (const [errorKey, errorValue] of Object.entries(control.errors)) {
+            const rule = rules.find((r) => this.normalizeValidationKey(r.type) === errorKey ||
+                (r.type === 'crossField' && errorKey === 'crossField'));
+            if (rule?.message) {
+                messages.push(rule.message);
+            }
+            else {
+                messages.push(this.getDefaultErrorMessage(errorKey, errorValue));
+            }
+        }
+        return messages;
+    }
+    /**
+     * Indica se mostrare gli errori per un controllo (invalid + touched/dirty/prevalorizzato).
+     */
+    shouldShowFieldErrors(control, options = {}) {
+        if (!control)
+            return false;
+        return (control.invalid &&
+            (control.dirty || control.touched || options.treatAsPrevalorized === true));
+    }
+    /**
+     * Conteggio caratteri corrente/massimo per campi text/textarea con maxLength.
+     */
+    getCharCount(control, maxLength) {
+        if (maxLength == null || maxLength <= 0)
+            return null;
+        const current = String(control?.value ?? '').length;
+        return { current, max: maxLength };
+    }
+    /** Estrae maxLength dalle regole schema. */
+    resolveMaxLength(rules = []) {
+        const rule = rules.find((r) => r.type === 'maxLength');
+        return rule?.value != null ? Number(rule.value) : undefined;
+    }
+    normalizeValidationKey(schemaType) {
+        const keyMap = {
+            minLength: 'minlength',
+            maxLength: 'maxlength',
+        };
+        return keyMap[schemaType] || schemaType;
+    }
+    getDefaultErrorMessage(errorKey, errorValue) {
+        if (typeof errorValue === 'string') {
+            return errorValue;
+        }
+        const ev = errorValue;
+        switch (errorKey) {
+            case 'required':
+                return 'Campo obbligatorio';
+            case 'email':
+                return 'Formato email non valido';
+            case 'min':
+                return `Valore minimo: ${ev?.['min']}`;
+            case 'max':
+                return `Valore massimo: ${ev?.['max']}`;
+            case 'minlength':
+                return `Lunghezza minima: ${ev?.['requiredLength']} caratteri`;
+            case 'maxlength':
+                return `Lunghezza massima: ${ev?.['requiredLength']} caratteri`;
+            case 'pattern':
+                return 'Formato non valido';
+            case 'crossField':
+                return 'Valore non coerente con il campo correlato';
+            case 'date-min':
+                return ev?.['message'] || 'Data troppo remota';
+            case 'date-max':
+                return ev?.['message'] || 'Data troppo avanzata';
+            case 'fileSize':
+                return `Dimensione massima: ${ev?.['maxSizeFormatted']}`;
+            case 'fileType':
+                return 'Formato file non accettato';
+            case 'fileCount':
+                return `Massimo ${ev?.['maxCount']} file`;
+            default:
+                return 'Valore non valido';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-field-error.service.js","sourceRoot":"","sources":["../../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/form-field-error.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { UiValidationRule } from '../types/validation.types';\r\n\r\n/** Opzioni per la visibilità degli errori di un campo. */\r\nexport interface UiFieldErrorDisplayOptions {\r\n  /** Tratta il campo come prevalorizzato (mostra errori anche senza touched). */\r\n  treatAsPrevalorized?: boolean;\r\n}\r\n\r\n/**\r\n * Servizio condiviso per messaggi di errore, visibilità errori e conteggio caratteri\r\n * dei campi form-builder e dei componenti atomici standalone.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiFormFieldErrorService {\r\n  /**\r\n   * Restituisce i messaggi di errore user-facing per un controllo.\r\n   *\r\n   * @param control Controllo Angular del campo\r\n   * @param rules Regole di validazione dichiarative (messaggi custom dallo schema)\r\n   */\r\n  getFieldErrors(control: AbstractControl | null, rules: UiValidationRule[] = []): string[] {\r\n    if (!control?.errors) return [];\r\n\r\n    const messages: string[] = [];\r\n    for (const [errorKey, errorValue] of Object.entries(control.errors)) {\r\n      const rule = rules.find(\r\n        (r) =>\r\n          this.normalizeValidationKey(r.type) === errorKey ||\r\n          (r.type === 'crossField' && errorKey === 'crossField'),\r\n      );\r\n      if (rule?.message) {\r\n        messages.push(rule.message);\r\n      } else {\r\n        messages.push(this.getDefaultErrorMessage(errorKey, errorValue));\r\n      }\r\n    }\r\n    return messages;\r\n  }\r\n\r\n  /**\r\n   * Indica se mostrare gli errori per un controllo (invalid + touched/dirty/prevalorizzato).\r\n   */\r\n  shouldShowFieldErrors(\r\n    control: AbstractControl | null,\r\n    options: UiFieldErrorDisplayOptions = {},\r\n  ): boolean {\r\n    if (!control) return false;\r\n    return (\r\n      control.invalid &&\r\n      (control.dirty || control.touched || options.treatAsPrevalorized === true)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Conteggio caratteri corrente/massimo per campi text/textarea con maxLength.\r\n   */\r\n  getCharCount(\r\n    control: AbstractControl | null,\r\n    maxLength?: number,\r\n  ): { current: number; max: number } | null {\r\n    if (maxLength == null || maxLength <= 0) return null;\r\n    const current = String(control?.value ?? '').length;\r\n    return { current, max: maxLength };\r\n  }\r\n\r\n  /** Estrae maxLength dalle regole schema. */\r\n  resolveMaxLength(rules: UiValidationRule[] = []): number | undefined {\r\n    const rule = rules.find((r) => r.type === 'maxLength');\r\n    return rule?.value != null ? Number(rule.value) : undefined;\r\n  }\r\n\r\n  private normalizeValidationKey(schemaType: string): string {\r\n    const keyMap: Record<string, string> = {\r\n      minLength: 'minlength',\r\n      maxLength: 'maxlength',\r\n    };\r\n    return keyMap[schemaType] || schemaType;\r\n  }\r\n\r\n  private getDefaultErrorMessage(errorKey: string, errorValue: unknown): string {\r\n    if (typeof errorValue === 'string') {\r\n      return errorValue;\r\n    }\r\n\r\n    const ev = errorValue as Record<string, unknown> | null | undefined;\r\n\r\n    switch (errorKey) {\r\n      case 'required':\r\n        return 'Campo obbligatorio';\r\n      case 'email':\r\n        return 'Formato email non valido';\r\n      case 'min':\r\n        return `Valore minimo: ${ev?.['min']}`;\r\n      case 'max':\r\n        return `Valore massimo: ${ev?.['max']}`;\r\n      case 'minlength':\r\n        return `Lunghezza minima: ${ev?.['requiredLength']} caratteri`;\r\n      case 'maxlength':\r\n        return `Lunghezza massima: ${ev?.['requiredLength']} caratteri`;\r\n      case 'pattern':\r\n        return 'Formato non valido';\r\n      case 'crossField':\r\n        return 'Valore non coerente con il campo correlato';\r\n      case 'date-min':\r\n        return (ev?.['message'] as string) || 'Data troppo remota';\r\n      case 'date-max':\r\n        return (ev?.['message'] as string) || 'Data troppo avanzata';\r\n      case 'fileSize':\r\n        return `Dimensione massima: ${ev?.['maxSizeFormatted']}`;\r\n      case 'fileType':\r\n        return 'Formato file non accettato';\r\n      case 'fileCount':\r\n        return `Massimo ${ev?.['maxCount']} file`;\r\n      default:\r\n        return 'Valore non valido';\r\n    }\r\n  }\r\n}\r\n"]}