@wemake4u/form-player-se 1.0.23 → 1.0.25

package/esm2022/lib/services/form.service.mjs

@@ -0,0 +1,360 @@
+import { Injectable } from '@angular/core';
+import { FormGroup, FormArray, FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+;
+export class FormService {
+    set(control, path, value, pathOptions, patchOptions) {
+        const currentControl = this.applyPath(control, path, pathOptions ?? { create: true });
+        if (!currentControl)
+            return false;
+        this.patch(currentControl, value, patchOptions);
+        return true;
+    }
+    get(control, path, pathOptions) {
+        const result = this.getControl(control, path, pathOptions);
+        return result?.value;
+    }
+    getControl(control, path, pathOptions) {
+        return this.applyPath(control, path, pathOptions);
+    }
+    prepend(control, path, value, pathOptions, patchOptions) {
+        const formArray = this.applyPath(control, path, pathOptions ?? { expected: "array", create: true });
+        if (formArray instanceof FormArray) {
+            return this.insertIntoArray(formArray, 0, value, patchOptions);
+        }
+        return false;
+    }
+    append(control, path, value, pathOptions, patchOptions) {
+        const formArray = this.applyPath(control, path, pathOptions ?? { expected: "array", create: true });
+        if (formArray instanceof FormArray) {
+            return this.insertIntoArray(formArray, formArray.length, value, patchOptions);
+        }
+        return false;
+    }
+    insert(control, path, index, value, pathOptions, patchOptions) {
+        const formArray = this.applyPath(control, path, pathOptions ?? { expected: "array", create: true });
+        if (formArray instanceof FormArray) {
+            return this.insertIntoArray(formArray, index, value, patchOptions);
+        }
+        return false;
+    }
+    remove(control, path, index) {
+        const formArray = this.applyPath(control, path);
+        if (formArray instanceof FormArray) {
+            return this.removeFromArray(formArray, index);
+        }
+        return false;
+    }
+    moveUp(control, path, index) {
+        const formArray = this.applyPath(control, path);
+        if (formArray instanceof FormArray) {
+            if (index <= 0 || index >= formArray.length)
+                return false;
+            const control = formArray.at(index);
+            formArray.removeAt(index);
+            formArray.insert(index - 1, control);
+            return true;
+        }
+        return false;
+    }
+    moveDown(control, path, index) {
+        const formArray = this.applyPath(control, path);
+        if (formArray instanceof FormArray) {
+            if (index < 0 || index >= formArray.length - 1)
+                return false;
+            const control = formArray.at(index);
+            formArray.removeAt(index);
+            formArray.insert(index + 1, control);
+            return true;
+        }
+        return false;
+    }
+    status(control, path, pathOptions) {
+        const result = this.applyPath(control, path, pathOptions);
+        return result?.status;
+    }
+    getInvalidControls(control) {
+        const invalid = [];
+        if (control.invalid) {
+            invalid.push({ path: this.getPath(control).join("."), control });
+        }
+        if (control instanceof FormGroup || control instanceof FormArray) {
+            const children = Object.values(control.controls);
+            for (const child of children) {
+                invalid.push(...this.getInvalidControls(child));
+            }
+        }
+        return invalid;
+    }
+    patch(control, value, options) {
+        const defaultOptions = {
+            emitEvent: true,
+            validateType: false,
+            fallbackValue: null,
+            strict: true
+        };
+        const warn = (message) => {
+            if (options?.emitWarn)
+                console.warn(`[patchControl] ${message}`);
+        };
+        const error = (message) => {
+            if (options?.emitError)
+                throw new Error(message);
+        };
+        const { emitEvent, validateType, fallbackValue, strict } = { ...defaultOptions, ...options };
+        if (control instanceof FormControl) {
+            if (validateType && typeof value !== typeof control.value) {
+                warn(`Value type mismatch: expected ${typeof control.value}, but received ${typeof value}`);
+                if (fallbackValue !== null) {
+                    control.patchValue(fallbackValue, { emitEvent });
+                    return;
+                }
+                error('Invalid value type and no fallback value provided.');
+                return;
+            }
+            control.patchValue(value, { emitEvent });
+        }
+        else if (control instanceof FormGroup) {
+            const currentValue = this.asObject(value);
+            Object.keys(currentValue).forEach((key) => {
+                if (control.controls[key]) {
+                    this.patch(control.controls[key], value[key], options);
+                }
+                else if (!strict) {
+                    const newControl = this.createControlFromValue(value[key]);
+                    this.setUnknown(newControl);
+                    control.addControl(key, newControl);
+                    this.patch(newControl, value[key], options);
+                }
+                else {
+                    warn(`Key "${key}" not found in the FormGroup.`);
+                }
+            });
+            Object.keys(control.controls).forEach((key) => {
+                if (!(key in currentValue)) {
+                    const childControl = control.get(key);
+                    if (childControl) {
+                        childControl.reset();
+                    }
+                }
+            });
+        }
+        else if (control instanceof FormArray) {
+            const currentValue = this.asArray(value);
+            while (control.length < currentValue.length) {
+                const anyControl = control;
+                const itemToAdd = currentValue[control.length];
+                if (typeof (anyControl).addItem === 'function') {
+                    anyControl.addItem();
+                }
+                else {
+                    control.push(this.createControlFromValue(itemToAdd));
+                }
+            }
+            while (control.length > currentValue.length) {
+                control.removeAt(control.length - 1);
+            }
+            currentValue.forEach((item, index) => {
+                this.patch(control.at(index), item, options);
+            });
+        }
+        else {
+            error('Unsupported AbstractControl type.');
+        }
+    }
+    getPath(control) {
+        const path = [];
+        let current = control;
+        while (current?.parent) {
+            const parent = current.parent;
+            if (parent instanceof FormArray) {
+                const index = parent.controls.indexOf(current);
+                path.unshift(index);
+            }
+            else if (parent instanceof FormGroup) {
+                const key = Object.keys(parent.controls).find(k => parent.get(k) === current);
+                if (key) {
+                    path.unshift(key);
+                }
+            }
+            current = parent;
+        }
+        return path;
+    }
+    getContext(formGroup) {
+        if (!(formGroup instanceof FormGroup)) {
+            throw new Error("Scope is not a FormGroup");
+        }
+        const patchOptions = {
+            strict: false
+        };
+        return {
+            set: (path, value, pathOptions) => this.set(formGroup, path, value, pathOptions, patchOptions),
+            get: (path, pathOptions) => this.get(formGroup, path, pathOptions),
+            status: (path, pathOptions) => this.status(formGroup, path, pathOptions),
+            prepend: (path, value, pathOptions) => this.prepend(formGroup, path, value, pathOptions, patchOptions),
+            append: (path, value, pathOptions) => this.append(formGroup, path, value, pathOptions, patchOptions),
+            insert: (path, index, value, pathOptions) => this.insert(formGroup, path, index, value, pathOptions, patchOptions),
+            remove: (path, index) => this.remove(formGroup, path, index),
+            moveUp: (path, index) => this.moveUp(formGroup, path, index),
+            moveDown: (path, index) => this.moveDown(formGroup, path, index)
+        };
+    }
+    applyPath(control, path, options) {
+        const warn = (message) => {
+            if (options?.emitWarn)
+                console.warn(`[applyPath] ${message}`);
+        };
+        const error = (message) => {
+            if (options?.emitError)
+                throw new Error(`[applyPath] ${message}`);
+            throw new Error(`[applyPath] ${message}`); // fallback default behavior
+        };
+        const createControl = (type) => {
+            switch (type) {
+                case 'array': return new FormArray([]);
+                case 'group': return new FormGroup({});
+                case 'control':
+                default: return new FormControl(null);
+            }
+        };
+        const normalizePath = (path) => {
+            if (typeof path === 'string') {
+                return path.split('.');
+            }
+            if (Array.isArray(path)) {
+                return path.reduce((acc, part) => {
+                    if (typeof part === 'string') {
+                        acc.push(...part.split('.'));
+                    }
+                    else {
+                        acc.push(part);
+                    }
+                    return acc;
+                }, []);
+            }
+            return [path];
+        };
+        const segments = normalizePath(path);
+        let current = control;
+        const createPath = options?.create ?? false;
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const isLeaf = i === segments.length - 1;
+            const nextType = isLeaf ? (options?.expected ?? 'control')
+                : typeof segments[i + 1] === 'number' ? 'array'
+                    : 'group';
+            const getCurrentPath = () => segments.slice(0, i + 1).join('.');
+            if (!current) {
+                return error(`Control is null at segment "${getCurrentPath()}"`);
+            }
+            if (!segment) {
+                continue;
+            }
+            else if (typeof segment === 'number') {
+                if (!(current instanceof FormArray)) {
+                    return error(`Expected FormArray at segment [${getCurrentPath()}], got ${current.constructor.name}`);
+                }
+                const index = segment;
+                if (index < 0 || index >= current.length) {
+                    warn(`Index ${index} is out of bounds at path "${getCurrentPath()}" (length = ${current.length})`);
+                    return undefined;
+                }
+                current = current.at(index);
+            }
+            else if (typeof segment === 'string') {
+                if (segment === 'parent') {
+                    current = (current instanceof FormGroup) && current.get(segment)
+                        ? current.get(segment)
+                        : current.parent;
+                    continue;
+                }
+                if (segment === 'root') {
+                    current = (current instanceof FormGroup && current.get(segment))
+                        ? current.get(segment)
+                        : current.root;
+                    continue;
+                }
+                if (!(current instanceof FormGroup)) {
+                    return error(`Expected FormGroup at segment "${getCurrentPath()}", got ${current.constructor.name}`);
+                }
+                if (current.get(segment)) {
+                    current = current.get(segment);
+                }
+                else {
+                    if (createPath) {
+                        const newControl = createControl(nextType);
+                        current.addControl(segment, newControl);
+                        current = newControl;
+                    }
+                    else {
+                        warn(`Control with key "${getCurrentPath()}" not found in FormGroup.`);
+                        return undefined;
+                    }
+                }
+            }
+            else {
+                return error(`Invalid segment type: ${typeof segment}`);
+            }
+        }
+        return current ?? undefined;
+    }
+    asObject(value) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return value;
+        }
+        return {};
+    }
+    asArray(value) {
+        if (value && Array.isArray(value)) {
+            return value;
+        }
+        return [];
+    }
+    insertIntoArray(formArray, index, value, options) {
+        const itemToAdd = this.createArrayItem(formArray);
+        this.patch(itemToAdd, value, options);
+        formArray.insert(index, itemToAdd);
+        return true;
+    }
+    removeFromArray(formArray, index) {
+        if (index <= 0 || index >= formArray.length)
+            false;
+        formArray.removeAt(index);
+        return true;
+    }
+    createArrayItem(formArray) {
+        const anyControl = formArray;
+        const formGroup = (typeof (anyControl).createItem === 'function')
+            ? anyControl.createItem()
+            : new FormGroup({});
+        return formGroup;
+    }
+    createControlFromValue(value) {
+        if (value === null || typeof value !== 'object') {
+            return new FormControl(value);
+        }
+        if (Array.isArray(value)) {
+            return new FormArray(this.createControlFromArray(value));
+        }
+        return new FormGroup({});
+    }
+    createControlFromArray(array) {
+        return array.map(item => this.createControlFromValue(item));
+    }
+    setUnknown(control) {
+        control._unknown = true;
+    }
+    isUnknown(control) {
+        return control && control._unknown === true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/services/form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { IEvaluatorProvider } from './programmability.service';\r\nimport { AbstractControl, FormGroup, FormArray, FormControl, FormControlStatus } from '@angular/forms';\r\n\r\nexport type Path = string | number | Array<string | number>;\r\n\r\ntype ControlType = 'array' | 'group' | 'control';\r\n\r\nexport interface PatchOptions {\r\n  emitEvent?: boolean;\r\n  emitError?: boolean;\r\n  emitWarn?: boolean;\r\n  validateType?: boolean;\r\n  fallbackValue?: any;\r\n  strict: boolean;\r\n}\r\n\r\nexport interface PathOptions {\r\n  emitError?: boolean;\r\n  emitWarn?: boolean;\r\n  create?: boolean;\r\n  expected?: ControlType;\r\n};\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class FormService implements IEvaluatorProvider {\r\n\r\n  set(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean {\r\n\r\n    const currentControl = this.applyPath(control, path, pathOptions ?? { create: true });\r\n\r\n    if (!currentControl)\r\n      return false;\r\n\r\n    this.patch(currentControl, value, patchOptions);\r\n\r\n    return true;\r\n  }\r\n\r\n  get(control: AbstractControl, path: Path, pathOptions?: PathOptions): any {\r\n    const result = this.getControl(control, path, pathOptions);\r\n    return result?.value;\r\n  }\r\n\r\n  getControl(control: AbstractControl, path: Path, pathOptions?: PathOptions): AbstractControl | undefined {\r\n    return this.applyPath(control, path, pathOptions);\r\n  }\r\n\r\n  prepend(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean {\r\n    const formArray = this.applyPath(control, path, pathOptions ?? { expected: \"array\", create: true });\r\n    if (formArray instanceof FormArray) {\r\n      return this.insertIntoArray(formArray, 0, value, patchOptions);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  append(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean {\r\n    const formArray = this.applyPath(control, path, pathOptions ?? { expected: \"array\", create: true });\r\n    if (formArray instanceof FormArray) {\r\n      return this.insertIntoArray(formArray, formArray.length, value, patchOptions);      \r\n    }\r\n    return false;\r\n  }\r\n\r\n  insert(control: AbstractControl, path: Path, index: number, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean {\r\n    const formArray = this.applyPath(control, path, pathOptions ?? { expected: \"array\", create: true });\r\n    if (formArray instanceof FormArray) {\r\n      return this.insertIntoArray(formArray, index, value, patchOptions);  \r\n    }\r\n    return false;\r\n  }\r\n\r\n  remove(control: AbstractControl, path: Path, index: number): boolean {\r\n    const formArray = this.applyPath(control, path);\r\n    if (formArray instanceof FormArray) {\r\n      return this.removeFromArray(formArray, index);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  moveUp(control: AbstractControl, path: Path, index: number): boolean {\r\n    const formArray = this.applyPath(control, path);\r\n    if (formArray instanceof FormArray) {\r\n      if (index <= 0 || index >= formArray.length) return false;\r\n\r\n      const control: AbstractControl = formArray.at(index);\r\n      formArray.removeAt(index);\r\n      formArray.insert(index - 1, control);\r\n\r\n      return true;\r\n    }    \r\n    return false;\r\n  }\r\n\r\n  moveDown(control: AbstractControl, path: Path, index: number): boolean {\r\n    const formArray = this.applyPath(control, path);\r\n    if (formArray instanceof FormArray) {\r\n      if (index < 0 || index >= formArray.length - 1) return false;\r\n\r\n      const control: AbstractControl = formArray.at(index);\r\n      formArray.removeAt(index);\r\n      formArray.insert(index + 1, control);\r\n\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  status(control: AbstractControl, path: Path, pathOptions?: PathOptions) : FormControlStatus | undefined {\r\n    const result = this.applyPath(control, path, pathOptions);\r\n    return result?.status;\r\n  }\r\n\r\n  getInvalidControls(control: AbstractControl): { path: string, control: AbstractControl }[] {\r\n    const invalid: { path: string, control: AbstractControl }[] = [];\r\n\r\n    if (control.invalid) {\r\n      invalid.push({ path: this.getPath(control).join(\".\"), control });\r\n    }\r\n\r\n    if (control instanceof FormGroup || control instanceof FormArray) {\r\n      const children = Object.values(control.controls);\r\n      for (const child of children) {\r\n        invalid.push(...this.getInvalidControls(child));\r\n      }\r\n    }\r\n\r\n    return invalid;\r\n  }\r\n\r\n  patch(\r\n    control: AbstractControl, value: any, options?: PatchOptions): void {\r\n\r\n    const defaultOptions = {\r\n      emitEvent: true,\r\n      validateType: false,\r\n      fallbackValue: null,\r\n      strict: true\r\n    };\r\n\r\n    const warn = (message: string) => {\r\n      if (options?.emitWarn)\r\n        console.warn(`[patchControl] ${message}`)\r\n    };\r\n\r\n    const error = (message: string) => {\r\n      if (options?.emitError)\r\n        throw new Error(message);\r\n    };\r\n\r\n    const { emitEvent, validateType, fallbackValue, strict }\r\n      = { ...defaultOptions, ...options };\r\n\r\n    if (control instanceof FormControl) {\r\n      if (validateType && typeof value !== typeof control.value) {\r\n        warn(`Value type mismatch: expected ${typeof control.value}, but received ${typeof value}`);\r\n\r\n        if (fallbackValue !== null) {\r\n          control.patchValue(fallbackValue, { emitEvent });\r\n          return;\r\n        }\r\n        error('Invalid value type and no fallback value provided.');\r\n        return;\r\n      }\r\n      control.patchValue(value, { emitEvent });\r\n    }\r\n    else if (control instanceof FormGroup) {\r\n      const currentValue = this.asObject(value);\r\n      Object.keys(currentValue).forEach((key) => {\r\n        if (control.controls[key]) {\r\n          this.patch(control.controls[key], value[key], options);\r\n        }\r\n        else if (!strict) {\r\n          const newControl = this.createControlFromValue(value[key]);\r\n          this.setUnknown(newControl);\r\n          control.addControl(key, newControl);\r\n          this.patch(newControl, value[key], options);\r\n        }\r\n        else {\r\n          warn(`Key \"${key}\" not found in the FormGroup.`);\r\n        }\r\n      });\r\n      Object.keys(control.controls).forEach((key) => {\r\n        if (!(key in currentValue)) {\r\n          const childControl = control.get(key);\r\n          if (childControl) {\r\n            childControl.reset();\r\n          }\r\n        }\r\n      });     \r\n    }\r\n    else if (control instanceof FormArray) {\r\n      const currentValue = this.asArray(value);\r\n      while (control.length < currentValue.length) {\r\n        const anyControl = control as any;\r\n        const itemToAdd = currentValue[control.length];\r\n        if (typeof (anyControl).addItem === 'function') {\r\n          anyControl.addItem();\r\n        } else {\r\n          control.push(this.createControlFromValue(itemToAdd));\r\n        }\r\n      }\r\n      while (control.length > currentValue.length) {\r\n        control.removeAt(control.length - 1);\r\n      }\r\n      currentValue.forEach((item: any, index: number) => {\r\n        this.patch(control.at(index), item, options);\r\n      });\r\n    }\r\n    else {\r\n      error('Unsupported AbstractControl type.');\r\n    }\r\n  }\r\n\r\n  getPath(control: AbstractControl): (string | number)[] {\r\n    const path: (string | number)[] = [];\r\n    let current: AbstractControl | null = control;\r\n\r\n    while (current?.parent) {\r\n      const parent: any = current.parent;\r\n\r\n      if (parent instanceof FormArray) {\r\n        const index = parent.controls.indexOf(current);\r\n        path.unshift(index);\r\n      } else if (parent instanceof FormGroup) {\r\n        const key = Object.keys(parent.controls).find(k => parent.get(k) === current);\r\n        if (key) {\r\n          path.unshift(key);\r\n        }\r\n      }\r\n\r\n      current = parent;\r\n    }\r\n\r\n    return path;\r\n  }\r\n\r\n  getContext(formGroup: any): Record<string, any> {\r\n    if (!(formGroup instanceof FormGroup)) {\r\n      throw new Error(\"Scope is not a FormGroup\");\r\n    }\r\n    const patchOptions: PatchOptions = {\r\n      strict: false\r\n    };\r\n\r\n    return {\r\n      set: (path: Path, value: any, pathOptions?: PathOptions): boolean =>\r\n        this.set(formGroup, path, value, pathOptions, patchOptions),\r\n\r\n      get: (path: Path, pathOptions?: PathOptions): AbstractControl | undefined =>\r\n        this.get(formGroup, path, pathOptions),\r\n\r\n      status: (path: Path, pathOptions?: PathOptions): FormControlStatus | undefined =>\r\n        this.status(formGroup, path, pathOptions),\r\n\r\n      prepend: (path: Path, value: any, pathOptions?: PathOptions): boolean =>\r\n        this.prepend(formGroup, path, value, pathOptions, patchOptions),\r\n\r\n      append: (path: Path, value: any, pathOptions?: PathOptions): boolean =>\r\n        this.append(formGroup, path, value, pathOptions, patchOptions),\r\n\r\n      insert: (path: Path, index: number, value: any, pathOptions?: PathOptions): boolean =>\r\n        this.insert(formGroup, path, index, value, pathOptions, patchOptions),\r\n\r\n      remove: (path: Path, index: number): boolean =>\r\n        this.remove(formGroup, path, index),\r\n\r\n      moveUp: (path: Path, index: number): boolean =>\r\n        this.moveUp(formGroup, path, index),\r\n\r\n      moveDown: (path: Path, index: number): boolean =>\r\n        this.moveDown(formGroup, path, index)\r\n    };\r\n  }\r\n\r\n  private applyPath(\r\n    control: AbstractControl,\r\n    path: Path,\r\n    options?: PathOptions\r\n  ): AbstractControl | undefined {\r\n    const warn = (message: string) => {\r\n      if (options?.emitWarn) console.warn(`[applyPath] ${message}`);\r\n    };\r\n\r\n    const error = (message: string): never => {\r\n      if (options?.emitError) throw new Error(`[applyPath] ${message}`);\r\n      throw new Error(`[applyPath] ${message}`); // fallback default behavior\r\n    };\r\n\r\n    const createControl = (type: ControlType): AbstractControl => {\r\n      switch (type) {\r\n        case 'array': return new FormArray([]);\r\n        case 'group': return new FormGroup({});\r\n        case 'control': default: return new FormControl(null);\r\n      }\r\n    };\r\n\r\n    const normalizePath = (path: Path): (string | number)[] => {\r\n      if (typeof path === 'string') {\r\n        return path.split('.');\r\n      }\r\n      if (Array.isArray(path)) {\r\n        return path.reduce<(string | number)[]>((acc, part) => {\r\n          if (typeof part === 'string') {\r\n            acc.push(...part.split('.'));\r\n          } else {\r\n            acc.push(part);\r\n          }\r\n          return acc;\r\n        }, []);\r\n      }\r\n      return [path];\r\n    };\r\n\r\n    const segments = normalizePath(path);\r\n    let current: AbstractControl | null = control;\r\n    const createPath = options?.create ?? false;\r\n\r\n    for (let i = 0; i < segments.length; i++) {\r\n      const segment = segments[i];\r\n      const isLeaf = i === segments.length - 1;\r\n      const nextType: ControlType =\r\n        isLeaf ? (options?.expected ?? 'control')\r\n          : typeof segments[i + 1] === 'number' ? 'array'\r\n            : 'group';\r\n\r\n      const getCurrentPath = () => segments.slice(0, i + 1).join('.');\r\n\r\n      if (!current) {\r\n        return error(`Control is null at segment \"${getCurrentPath()}\"`);\r\n      }\r\n\r\n      if (!segment) {\r\n        continue;\r\n      }\r\n      else if (typeof segment === 'number') {\r\n        if (!(current instanceof FormArray)) {\r\n          return error(`Expected FormArray at segment [${getCurrentPath()}], got ${current.constructor.name}`);\r\n        }\r\n\r\n        const index = segment;\r\n        if (index < 0 || index >= current.length) {\r\n          warn(`Index ${index} is out of bounds at path \"${getCurrentPath()}\" (length = ${current.length})`);\r\n          return undefined;\r\n        }\r\n\r\n        current = current.at(index);\r\n\r\n      } else if (typeof segment === 'string') {\r\n\r\n        if (segment === 'parent') {\r\n          current = (current instanceof FormGroup) && current.get(segment)\r\n            ? current.get(segment)\r\n            : current.parent;\r\n          continue;\r\n        }\r\n\r\n        if (segment === 'root') {\r\n          current = (current instanceof FormGroup && current.get(segment))\r\n            ? current.get(segment)\r\n            : current.root;\r\n          continue;\r\n        }\r\n\r\n        if (!(current instanceof FormGroup)) {\r\n          return error(`Expected FormGroup at segment \"${getCurrentPath()}\", got ${current.constructor.name}`);\r\n        }\r\n\r\n        if (current.get(segment)) {\r\n          current = current.get(segment);\r\n        } else {\r\n          if (createPath) {\r\n            const newControl = createControl(nextType);\r\n            current.addControl(segment, newControl);\r\n            current = newControl;\r\n          } else {\r\n            warn(`Control with key \"${getCurrentPath()}\" not found in FormGroup.`);\r\n            return undefined;\r\n          }\r\n        }\r\n\r\n      }      \r\n      else {\r\n        return error(`Invalid segment type: ${typeof segment}`);\r\n      }\r\n    }\r\n\r\n    return current ?? undefined;\r\n  }\r\n\r\n  private asObject(value: any): object {\r\n    if (value && typeof value === 'object' && !Array.isArray(value)) {\r\n      return value as Record<string, any>;\r\n    }\r\n    return { };\r\n  }\r\n\r\n  private asArray(value: any): Array<any> {\r\n    if (value && Array.isArray(value)) {\r\n      return value;\r\n    }\r\n    return [];\r\n  }\r\n\r\n  private insertIntoArray(formArray: FormArray, index: number, value: any, options?: PatchOptions): boolean {\r\n    const itemToAdd = this.createArrayItem(formArray);\r\n    this.patch(itemToAdd, value, options);\r\n    formArray.insert(index, itemToAdd);\r\n    return true;\r\n  }\r\n\r\n  private removeFromArray(formArray: FormArray, index: number): boolean {\r\n    if (index <= 0 || index >= formArray.length) false;\r\n    formArray.removeAt(index);\r\n    return true;\r\n  }\r\n\r\n  private createArrayItem(formArray: FormArray): FormGroup\r\n  {\r\n    const anyControl = formArray as any;\r\n    const formGroup = (typeof (anyControl).createItem === 'function')\r\n      ? anyControl.createItem()\r\n      : new FormGroup({});\r\n    return formGroup;\r\n  }\r\n\r\n  private createControlFromValue(value: any): AbstractControl {\r\n    if (value === null || typeof value !== 'object') {\r\n      return new FormControl(value);\r\n    }\r\n    if (Array.isArray(value)) {\r\n      return new FormArray(this.createControlFromArray(value));\r\n    }\r\n    return new FormGroup({});\r\n  }\r\n\r\n  private createControlFromArray(array: any[]): AbstractControl[] {\r\n    return array.map(item => this.createControlFromValue(item));\r\n  }\r\n\r\n  private setUnknown(control: any) {\r\n    control._unknown = true;\r\n  }\r\n\r\n  private isUnknown(control: any): boolean {\r\n    return control && control._unknown === true;\r\n  }\r\n}\r\n\r\n"]}

package/esm2022/lib/services/formatter.service.mjs

@@ -1,70 +1,84 @@
 import { Injectable } from '@angular/core';
+import { ToBoundArrows } from '../utils/functions';
 import * as i0 from "@angular/core";
-//import { FeelService } from '../services/feel.service';
 export class FormatterService {
-    //constructor(private feelService: FeelService) { }
     constructor() { }
-    formatCurrency(value, symbol = null) {
-        if (isNaN(value) || value === null || value === undefined) {
-            return value;
-        }
-        const numberValue = parseFloat(value);
-        if (isNaN(numberValue)) {
-            return value;
-        }
-        const result = numberValue.toFixed(2).replace(".", ",").replace(/\B(?=(\d{3})+(?!\d))/g, ".");
-        if (symbol) {
-            return symbol + ' ' + result;
-        }
-        else {
-            return result;
-        }
+    formatDate(isoDate, options, locale = 'it-IT') {
+        if (!isoDate)
+            return '';
+        const date = new Date(isoDate);
+        if (isNaN(date.getTime()))
+            return '';
+        const formatOptions = {
+            day: '2-digit',
+            month: '2-digit',
+            year: 'numeric',
+            ...options
+        };
+        return new Intl.DateTimeFormat(locale, formatOptions).format(date);
     }
-    formatDate(value) {
-        if (!value)
+    formatTime(isoDate, options, locale = 'it-IT') {
+        if (!isoDate)
             return '';
-        const date = new Date(value);
+        const date = new Date(isoDate);
         if (isNaN(date.getTime()))
             return '';
-        const day = String(date.getDate()).padStart(2, '0');
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const year = date.getFullYear();
-        return `${day}/${month}/${year}`;
+        const formatOptions = {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+            ...options
+        };
+        return new Intl.DateTimeFormat(locale, formatOptions).format(date);
     }
-    formatDateTime(value) {
-        if (!value)
+    formatDateTime(isoDate, options, locale = 'it-IT') {
+        if (!isoDate)
             return '';
-        const date = new Date(value);
+        const date = new Date(isoDate);
         if (isNaN(date.getTime()))
             return '';
-        const hasTime = typeof value === 'string' && value.includes('T');
-        const day = String(date.getDate()).padStart(2, '0');
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const year = date.getFullYear();
-        if (!hasTime) {
-            return `${day}/${month}/${year} 00:00:00`;
-        }
-        else {
-            const hours = String(date.getHours()).padStart(2, '0');
-            const minutes = String(date.getMinutes()).padStart(2, '0');
-            const seconds = String(date.getSeconds()).padStart(2, '0');
-            return `${day}/${month}/${year} ${hours}:${minutes}:${seconds}`;
-        }
+        const datePart = new Intl.DateTimeFormat(locale, {
+            day: '2-digit',
+            month: '2-digit',
+            year: 'numeric',
+            ...options
+        }).format(date);
+        const timePart = new Intl.DateTimeFormat(locale, {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+            ...options
+        }).format(date);
+        return `${datePart} ${timePart}`;
     }
-    formatInteger(value) {
-        if (isNaN(value) || value === null || value === undefined) {
-            return value;
-        }
-        const numberValue = parseInt(value, 10);
-        if (isNaN(numberValue)) {
-            return value;
-        }
-        return numberValue.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+    formatCurrency(value, currency = 'EUR', locale = 'it-IT') {
+        if (isNaN(value))
+            return '';
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currency,
+            currencyDisplay: 'symbol' // oppure: 'code' | 'name'
+        }).format(value);
+    }
+    formatNumber(value, decimals = 2, locale = 'it-IT') {
+        if (isNaN(value))
+            return '';
+        return new Intl.NumberFormat(locale, {
+            style: 'decimal',
+            minimumFractionDigits: decimals,
+            maximumFractionDigits: decimals
+        }).format(value);
     }
-    formatExpression(value, expression) {
-        return value;
-        //const result = this.feelService.evalExpression(expression, { value: value }) as string;
-        //return result;
+    getContext() {
+        return ToBoundArrows(this, [
+            'formatDate',
+            'formatTime',
+            'formatDateTime',
+            'formatCurrency',
+            'formatNumber'
+        ]);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormatterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormatterService, providedIn: 'root' });
@@ -75,4 +89,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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