@decaf-ts/for-angular 0.0.23 → 0.0.25

package/esm2022/engine/NgxFormService.mjs

@@ -66,12 +66,61 @@ export class NgxFormService {
      * @memberOf NgxFormService
      */
     static { this.formRegistry = new Map(); }
+    static { this.pageMapper = {}; }
+    /**
+     * @description Creates a new form group or form array with the specified identifier.
+     * @summary Generates a FormGroup or FormArray based on the provided properties. If pages are specified
+     * and greater than 1, creates a FormArray; otherwise creates a FormGroup. The form can optionally
+     * be registered in the global form registry for later access throughout the application.
+     *
+     * @param {string} id - Unique identifier for the form
+     * @param {Partial<IComponentInput>} [props={}] - Configuration properties for the form
+     * @param {boolean} [registry=true] - Whether to register the form in the global registry
+     * @return {FormGroup | FormArray} The created form instance
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant FR as Form Registry
+     *   participant AF as Angular Forms
+     *
+     *   C->>NFS: createForm(id, props, registry)
+     *   NFS->>FR: Check if form exists
+     *   alt Form doesn't exist
+     *     alt props.pages > 1
+     *       NFS->>AF: new FormArray([])
+     *     else
+     *       NFS->>AF: new FormGroup({})
+     *     end
+     *     alt registry is true
+     *       NFS->>FR: addRegistry(id, form)
+     *     end
+     *   end
+     *   NFS-->>C: Return FormGroup | FormArray
+     *
+     * @static
+     * @memberOf NgxFormService
+     */
+    static createForm(id, props = {}, registry = true) {
+        const form = this.formRegistry.get(id) ?? (props?.pages && props?.pages > 1 ? new FormArray([]) : new FormGroup({}));
+        if (!this.formRegistry.has(id) && registry)
+            this.addRegistry(id, form);
+        return form;
+    }
     /**
      * @description Adds a form to the registry.
-     * @summary Registers a FormGroup with a unique identifier. Throws an error if the identifier is already in use.
-     * @param {string} formId - The unique identifier for the form.
-     * @param {FormGroup} formGroup - The FormGroup to be registered.
-     * @throws {Error} If a FormGroup with the given id is already registered.
+     * @summary Registers a FormGroup or FormArray with a unique identifier for global access throughout
+     * the application. This allows forms to be retrieved and managed centrally. Throws an error if
+     * the identifier is already in use to prevent conflicts.
+     *
+     * @param {string} formId - The unique identifier for the form
+     * @param {FormParent} formGroup - The FormGroup or FormArray to be registered
+     * @return {void}
+     * @throws {Error} If a FormGroup with the given id is already registered
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static addRegistry(formId, formGroup) {
         if (this.formRegistry.has(formId))
@@ -80,8 +129,15 @@ export class NgxFormService {
     }
     /**
      * @description Removes a form from the registry.
-     * @summary Deletes a FormGroup from the registry using its unique identifier.
-     * @param {string} formId - The unique identifier of the form to be removed.
+     * @summary Deletes a FormGroup or FormArray from the registry using its unique identifier.
+     * This cleans up the registry and allows the identifier to be reused. The form itself
+     * is not destroyed, only removed from the central registry.
+     *
+     * @param {string} formId - The unique identifier of the form to be removed
+     * @return {void}
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static removeRegistry(formId) {
         this.formRegistry.delete(formId);
@@ -89,9 +145,38 @@ export class NgxFormService {
     /**
      * @description Resolves the parent group and control name from a path.
      * @summary Traverses the form group structure to find the parent group and control name for a given path.
-     * @param {FormGroup} formGroup - The root FormGroup.
-     * @param {string} path - The path to the control.
-     * @return {FormParentGroup} A tuple containing the parent FormGroup and the control name.
+     * Handles complex nested structures including arrays and sub-groups. Creates missing intermediate
+     * groups as needed and properly configures FormArray controls for multiple value scenarios.
+     *
+     * @param {FormGroup} formGroup - The root FormGroup to traverse
+     * @param {string} path - The dot-separated path to the control (e.g., 'user.address.street')
+     * @param {IComponentInput} componentProps - Properties defining the component configuration
+     * @param {KeyValue} parentProps - Properties from the parent component for context
+     * @return {FormParentGroup} A tuple containing the parent FormGroup and the control name
+     *
+     * @private
+     * @mermaid
+     * sequenceDiagram
+     *   participant NFS as NgxFormService
+     *   participant FG as FormGroup
+     *   participant FA as FormArray
+     *
+     *   NFS->>NFS: Split path into parts
+     *   loop For each path part
+     *     alt Control doesn't exist
+     *       alt isMultiple and part is childOf
+     *         NFS->>FA: new FormArray([new FormGroup({})])
+     *       else
+     *         NFS->>FG: new FormGroup({})
+     *       end
+     *       NFS->>FG: addControl(part, newControl)
+     *     end
+     *     NFS->>NFS: Navigate to next level
+     *   end
+     *   NFS-->>NFS: Return [parentGroup, controlName]
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static resolveParentGroup(formGroup, path, componentProps, parentProps) {
         const isMultiple = parentProps?.['multiple'] || parentProps?.['type'] === 'Array' || false;
@@ -270,19 +355,62 @@ export class NgxFormService {
         if (!parentGroup.get(controlName)) {
             const control = NgxFormService.fromProps(componentProps, componentProps.updateMode || 'change');
             NgxFormService.register(control, componentProps);
-            parentGroup.addControl(controlName, control);
+            if (parentGroup instanceof FormGroup) {
+                parentGroup.addControl(controlName, control);
+            }
+            if (parentGroup instanceof FormArray) {
+                const root = parentGroup.controls[componentProps?.['page'] - 1];
+                if (root) {
+                    root.addControl(controlName, control);
+                }
+                else {
+                    parentGroup.push({ [controlName]: control });
+                }
+            }
         }
-        componentProps['formGroup'] = parentGroup;
+        const root = parentGroup instanceof FormArray ? parentGroup.controls[componentProps?.['page'] - 1] : parentGroup;
+        componentProps['formGroup'] = root;
         componentProps['formControl'] = parentGroup.get(controlName);
         componentProps['multiple'] = isMultiple;
     }
     /**
      * @description Retrieves a control from a registered form.
      * @summary Finds and returns an AbstractControl from a registered form using the form id and optional path.
-     * @param {string} formId - The unique identifier of the form.
-     * @param {string} [path] - The path to the control within the form.
-     * @return {AbstractControl} The requested AbstractControl.
-     * @throws {Error} If the form is not found in the registry or the control is not found in the form.
+     * This method provides centralized access to form controls across the application by leveraging
+     * the form registry system.
+     *
+     * @param {string} formId - The unique identifier of the form in the registry
+     * @param {string} [path] - The optional dot-separated path to a specific control within the form
+     * @return {AbstractControl} The requested AbstractControl (FormGroup, FormArray, or FormControl)
+     * @throws {Error} If the form is not found in the registry or the control is not found in the form
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant FR as Form Registry
+     *
+     *   C->>NFS: getControlFromForm(formId, path?)
+     *   NFS->>FR: Get form by formId
+     *   alt Form not found
+     *     FR-->>NFS: null
+     *     NFS-->>C: Throw Error
+     *   else Form found
+     *     FR-->>NFS: Return form
+     *     alt path provided
+     *       NFS->>NFS: form.get(path)
+     *       alt Control not found
+     *         NFS-->>C: Throw Error
+     *       else
+     *         NFS-->>C: Return control
+     *       end
+     *     else
+     *       NFS-->>C: Return form
+     *     end
+     *   end
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static getControlFromForm(formId, path) {
         const form = this.formRegistry.get(formId);
@@ -295,13 +423,77 @@ export class NgxFormService {
             throw new Error(`Control with path '${path}' not found in form '${formId}'.`);
         return control;
     }
+    /**
+     * @description Creates a form from UI model metadata children.
+     * @summary Generates a FormGroup from an array of UIModelMetadata objects, extracting component
+     * properties and creating appropriate form controls. This method is specifically designed to work
+     * with the UI decorator system and provides automatic form generation from metadata.
+     *
+     * @param {string} id - Unique identifier for the form
+     * @param {boolean} [registry=false] - Whether to register the created form in the global registry
+     * @param {UIModelMetadata[]} [children] - Array of UI model metadata objects to create controls from
+     * @return {FormGroup} The created FormGroup with controls for each child metadata
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant AF as Angular Forms
+     *
+     *   C->>NFS: createFormFromChildren(id, registry, children)
+     *   NFS->>AF: new FormGroup({})
+     *   loop For each child metadata
+     *     NFS->>NFS: addFormControl(form, child.props)
+     *     NFS->>AF: Create and add FormControl
+     *   end
+     *   alt registry is true
+     *     NFS->>NFS: addRegistry(id, form)
+     *   end
+     *   NFS-->>C: Return FormGroup
+     *
+     * @static
+     * @memberOf NgxFormService
+     */
+    static createFormFromChildren(id, registry = false, children) {
+        const form = new FormGroup({});
+        if (children?.length)
+            children.forEach(child => {
+                this.addFormControl(form, child.props);
+            });
+        if (registry)
+            this.addRegistry(id, form);
+        return form;
+    }
     /**
      * @description Creates a form from component configurations.
      * @summary Generates a FormGroup based on an array of component configurations and optionally registers it.
-     * @param {string} id - The unique identifier for the form.
-     * @param {IComponentConfig[]} components - An array of component configurations.
-     * @param {boolean} [registry=false] - Whether to register the created form.
-     * @return {FormGroup} The created FormGroup.
+     * This method processes component input configurations to create appropriate form controls with
+     * validation and initial values.
+     *
+     * @param {string} id - The unique identifier for the form
+     * @param {IComponentConfig[]} components - An array of component configurations defining the form structure
+     * @param {boolean} [registry=false] - Whether to register the created form in the global registry
+     * @return {FormGroup} The created FormGroup with controls for each component configuration
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant AF as Angular Forms
+     *
+     *   C->>NFS: createFormFromComponents(id, components, registry)
+     *   NFS->>AF: new FormGroup({})
+     *   loop For each component config
+     *     NFS->>NFS: addFormControl(form, component.inputs)
+     *     NFS->>AF: Create and add FormControl
+     *   end
+     *   alt registry is true
+     *     NFS->>NFS: addRegistry(id, form)
+     *   end
+     *   NFS-->>C: Return FormGroup
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static createFormFromComponents(id, components, registry = false) {
         const form = new FormGroup({});
@@ -315,14 +507,61 @@ export class NgxFormService {
     /**
      * @description Adds a control to a form based on component properties.
      * @summary Creates and adds a form control to a form (existing or new) based on the provided component properties.
-     * @param {string} id - The unique identifier of the form.
-     * @param {FieldProperties} componentProperties - The properties of the component to create the control from.
-     * @return {AbstractControl} The form or created control.
+     * Handles multi-page forms by managing FormArray structures and proper indexing. This method supports
+     * complex form scenarios including nested controls and page-based form organization.
+     *
+     * @param {string} id - The unique identifier of the form
+     * @param {FieldProperties} componentProperties - The properties of the component to create the control from
+     * @param {FieldProperties} [parentProps] - Optional parent properties for context and configuration
+     * @return {AbstractControl} The form or created control
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant F as Form
+     *
+     *   C->>NFS: addControlFromProps(id, componentProps, parentProps?)
+     *   NFS->>NFS: createForm(id, parentProps, true)
+     *   alt Multi-page form (parentProps.pages > 1)
+     *     NFS->>NFS: Calculate page index
+     *     NFS->>F: Get or create FormGroup at index
+     *     NFS->>NFS: Set form to page FormGroup
+     *   end
+     *   alt componentProperties has path
+     *     NFS->>NFS: addFormControl(form, componentProperties, parentProps)
+     *   end
+     *   NFS-->>C: Return form/control
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static addControlFromProps(id, componentProperties, parentProps) {
-        const form = this.formRegistry.get(id) ?? new FormGroup({});
-        if (!this.formRegistry.has(id))
-            this.addRegistry(id, form);
+        let form = this.createForm(id, parentProps, true);
+        const formLength = form.length;
+        if (parentProps?.pages && parentProps?.pages > 1) {
+            let index = componentProperties.page || parentProps.page;
+            if (!(typeof index === 'number') || index === 0)
+                throw Error(`Property 'page' is required and greather than 0 on ${componentProperties.name}`);
+            if (index > formLength) {
+                if (form?.['lastIndex'] && index === form['lastIndex']['page']) {
+                    index = form['lastIndex']['index'];
+                }
+                else {
+                    form['lastIndex'] = {
+                        page: index,
+                        index: formLength + 1
+                    };
+                    index = formLength + 1;
+                }
+            }
+            let group = form.controls[index - 1];
+            if (!group) {
+                group = new FormGroup({});
+                form.insert(index, group);
+            }
+            form = group;
+        }
         if (componentProperties.path)
             this.addFormControl(form, componentProperties, parentProps);
         return form;
@@ -330,8 +569,45 @@ export class NgxFormService {
     /**
      * @description Retrieves form data from a FormGroup.
      * @summary Extracts and processes the data from a FormGroup, handling different input types and nested form groups.
-     * @param {FormGroup} formGroup - The FormGroup to extract data from.
-     * @return {Record<string, unknown>} An object containing the form data.
+     * Performs type conversion for various HTML5 input types, validates nested controls, and manages
+     * multiple control scenarios. Automatically enables all group controls after data extraction.
+     *
+     * @param {FormGroup} formGroup - The FormGroup to extract data from
+     * @return {Record<string, unknown>} An object containing the processed form data with proper type conversions
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant FG as FormGroup
+     *   participant FC as FormControl
+     *
+     *   C->>NFS: getFormData(formGroup)
+     *   loop For each control in formGroup
+     *     alt Control is not FormControl
+     *       NFS->>NFS: Recursive getFormData(control)
+     *       alt parentProps.multiple and !isValid
+     *         NFS->>NFS: reset(control)
+     *       end
+     *     else Control is FormControl
+     *       NFS->>FC: Get control value
+     *       NFS->>NFS: Apply type conversion based on props.type
+     *       alt HTML5CheckTypes
+     *         NFS->>NFS: Keep boolean value
+     *       else NUMBER type
+     *         NFS->>NFS: parseToNumber(value)
+     *       else DATE/DATETIME types
+     *         NFS->>NFS: new Date(value)
+     *       else Other types
+     *         NFS->>NFS: escapeHtml(value)
+     *       end
+     *     end
+     *   end
+     *   NFS->>NFS: enableAllGroupControls(formGroup)
+     *   NFS-->>C: Return processed data object
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static getFormData(formGroup) {
         const data = {};
@@ -376,10 +652,51 @@ export class NgxFormService {
     /**
      * @description Validates fields in a form control or form group.
      * @summary Recursively validates all fields in a form control or form group, marking them as touched and dirty.
-     * @param {AbstractControl} control - The control or form group to validate.
-     * @param {string} [path] - The path to the control within the form.
-     * @return {boolean} True if all fields are valid, false otherwise.
-     * @throws {Error} If no control is found at the specified path or if the control type is unknown.
+     * Performs comprehensive validation including uniqueness checks for primary keys in FormArray scenarios.
+     * This method ensures all validation rules are applied and form state is properly updated.
+     *
+     * @param {AbstractControl} control - The control or form group to validate
+     * @param {string} [pk] - Optional primary key field name for uniqueness validation
+     * @param {string} [path] - The path to the control within the form for error reporting
+     * @return {boolean} True if all fields are valid, false otherwise
+     * @throws {Error} If no control is found at the specified path or if the control type is unknown
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant FC as FormControl
+     *   participant FG as FormGroup
+     *   participant FA as FormArray
+     *
+     *   C->>NFS: validateFields(control, pk?, path?)
+     *   alt Control is FormControl
+     *     NFS->>FC: markAsTouched()
+     *     NFS->>FC: markAsDirty()
+     *     NFS->>FC: updateValueAndValidity()
+     *     alt Is in FormArray group
+     *       NFS->>NFS: Check uniqueness in group
+     *       alt Not unique
+     *         NFS->>FC: setErrors({notUnique: true})
+     *       end
+     *     end
+     *     NFS-->>C: Return control.valid
+     *   else Control is FormGroup
+     *     loop For each child control
+     *       NFS->>NFS: Recursive validateFields(child)
+     *     end
+     *     NFS-->>C: Return allValid
+     *   else Control is FormArray
+     *     loop For each array control
+     *       NFS->>NFS: Recursive validateFields(child)
+     *     end
+     *     NFS-->>C: Return allValid
+     *   else Unknown control type
+     *     NFS-->>C: Throw Error
+     *   end
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static validateFields(control, pk, path) {
         control = path ? control.get(path) : control;
@@ -419,13 +736,13 @@ export class NgxFormService {
                 });
             }
         }
-        function getControlName(control) {
-            const group = control.parent;
-            if (!group)
-                return null;
-            return Object.keys(group.controls).find(name => control === group.get(name)) || null;
-        }
-        return !getControlName(control) ? true : control.valid;
+        // function getControlName(control: AbstractControl): string | null {
+        //   const group = control.parent as FormGroup;
+        //   if (!group)
+        //       return null;
+        //   return Object.keys(group.controls).find(name => control === group.get(name)) || null;
+        // }
+        return control.valid;
     }
     /**
      * @description Generates validators from component properties.
@@ -443,10 +760,38 @@ export class NgxFormService {
     }
     /**
      * @description Creates a FormControl from component properties.
-     * @summary Generates a FormControl with validators based on the provided component properties.
-     * @param {FieldProperties} props - The component properties.
-     * @param {FieldUpdateMode} [updateMode='change'] - The update mode for the control.
-     * @return {FormControl} The created FormControl.
+     * @summary Generates a FormControl with validators and initial configuration based on the provided
+     * component properties. Handles different input types, sets initial values, and configures
+     * validation rules and update modes.
+     *
+     * @param {FieldProperties} props - The component properties defining the control configuration
+     * @param {FieldUpdateMode} [updateMode='change'] - The update mode for the control ('change', 'blur', 'submit')
+     * @return {FormControl} The created FormControl with proper configuration and validators
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant VF as ValidatorFactory
+     *   participant AF as Angular Forms
+     *
+     *   C->>NFS: fromProps(props, updateMode?)
+     *   NFS->>NFS: validatorsFromProps(props)
+     *   NFS->>VF: Create validators from props
+     *   VF-->>NFS: Return validator array
+     *   NFS->>NFS: Compose validators
+     *   alt props.value exists and not checkbox
+     *     alt props.type is DATE
+     *       NFS->>NFS: Validate date format
+     *     end
+     *     NFS->>NFS: Set initial value
+     *   end
+     *   NFS->>AF: new FormControl(config)
+     *   AF-->>NFS: Return FormControl
+     *   NFS-->>C: Return configured FormControl
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static fromProps(props, updateMode = 'change') {
         const validators = this.validatorsFromProps(props);
@@ -464,21 +809,50 @@ export class NgxFormService {
         });
     }
     /**
-     * @description Retrieves properties from a FormControl.
-     * @summary Gets the FieldProperties associated with a FormControl from the internal WeakMap.
-     * @param {FormControl} control - The FormControl to get properties for.
-     * @return {FieldProperties} The properties associated with the control.
+     * @description Retrieves properties from a FormControl, FormArray, or FormGroup.
+     * @summary Gets the FieldProperties associated with a form control from the internal WeakMap.
+     * This method provides access to the original component properties that were used to create
+     * the control, enabling validation, rendering, and behavior configuration.
+     *
+     * @param {FormControl | FormArray | FormGroup} control - The form control to get properties for
+     * @return {FieldProperties} The properties associated with the control, or empty object if not found
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static getPropsFromControl(control) {
         return this.controls.get(control) || {};
     }
     /**
-     * @description Finds a parent element with a specific tag.
-     * @summary Traverses up the DOM tree to find the nearest parent element with the specified tag.
-     * @param {HTMLElement} el - The starting element.
-     * @param {string} tag - The tag name to search for.
-     * @return {HTMLElement} The found parent element.
-     * @throws {Error} If no parent with the specified tag is found.
+     * @description Finds a parent element with a specific tag in the DOM tree.
+     * @summary Traverses up the DOM tree to find the nearest parent element with the specified tag name.
+     * This is useful for finding container elements or specific parent components in the DOM hierarchy.
+     * The search is case-insensitive for tag name matching.
+     *
+     * @param {HTMLElement} el - The starting element to traverse from
+     * @param {string} tag - The tag name to search for (case-insensitive)
+     * @return {HTMLElement} The found parent element with the specified tag
+     * @throws {Error} If no parent with the specified tag is found in the DOM tree
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant NFS as NgxFormService
+     *   participant DOM as DOM Tree
+     *
+     *   C->>NFS: getParentEl(element, tagName)
+     *   loop Traverse up DOM tree
+     *     NFS->>DOM: Get parentElement
+     *     DOM-->>NFS: Return parent or null
+     *     alt Parent exists and tag matches
+     *       NFS-->>C: Return parent element
+     *     else Parent is null
+     *       NFS-->>C: Throw Error
+     *     end
+     *   end
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static getParentEl(el, tag) {
         let parent;
@@ -491,10 +865,17 @@ export class NgxFormService {
         throw new Error(`No parent with the tag ${tag} was found for provided element`);
     }
     /**
-     * @description Registers a control with its properties.
-     * @summary Associates a control with its properties in the internal WeakMap.
-     * @param {AbstractControl} control - The control to register.
-     * @param {FieldProperties} props - The properties to associate with the control.
+     * @description Registers a control with its properties in the internal WeakMap.
+     * @summary Associates a form control with its component properties for later retrieval.
+     * This enables the service to maintain metadata about controls without creating memory leaks,
+     * as WeakMap automatically cleans up references when controls are garbage collected.
+     *
+     * @param {AbstractControl} control - The control to register (FormControl, FormGroup, or FormArray)
+     * @param {FieldProperties} props - The properties to associate with the control
+     * @return {void}
+     *
+     * @static
+     * @memberOf NgxFormService
      */
     static register(control, props) {
         this.controls.set(control, props);
@@ -533,4 +914,4 @@ export class NgxFormService {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxFormService.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxFormService.ts"],"names":[],"mappings":"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","sourcesContent":["import { escapeHtml, FieldProperties, HTML5CheckTypes, HTML5InputTypes, parseToNumber } from '@decaf-ts/ui-decorators';\nimport { FieldUpdateMode, FormParentGroup, KeyValue } from './types';\nimport { IComponentConfig, IComponentInput } from './interfaces';\nimport { AbstractControl, FormArray, FormControl, FormGroup, ValidatorFn, Validators } from '@angular/forms';\nimport { isValidDate, ModelKeys, parseDate, Primitives, Validation } from '@decaf-ts/decorator-validation';\nimport { ValidatorFactory } from './ValidatorFactory';\nimport { cleanSpaces } from '../helpers';\nimport { OperationKeys } from '@decaf-ts/db-decorators';\nimport { AngularEngineKeys, BaseComponentProps } from '../engine/constants';\n\n\n/**\n * @description Service for managing Angular forms and form controls.\n * @summary The NgxFormService provides utility methods for creating, managing, and validating Angular forms and form controls. It includes functionality for registering forms, adding controls, validating fields, and handling form data.\n *\n * @class\n * @param {WeakMap<AbstractControl, FieldProperties>} controls - A WeakMap to store control properties.\n * @param {Map<string, FormGroup>} formRegistry - A Map to store registered forms.\n *\n * @example\n * // Creating a form from components\n * const components = [\n *   { inputs: { name: 'username', type: 'text', required: true } },\n *   { inputs: { name: 'password', type: 'password', minLength: 8 } }\n * ];\n * const form = NgxFormService.createFormFromComponents('loginForm', components, true);\n *\n * // Validating fields\n * NgxFormService.validateFields(form);\n *\n * // Getting form data\n * const formData = NgxFormService.getFormData(form);\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Component\n *   participant NFS as NgxFormService\n *   participant AF as Angular Forms\n *   C->>NFS: createFormFromComponents()\n *   NFS->>AF: new FormGroup()\n *   NFS->>NFS: addFormControl()\n *   NFS->>AF: addControl()\n *   NFS-->>C: Return FormGroup\n *   C->>NFS: validateFields()\n *   NFS->>AF: markAsTouched(), markAsDirty(), updateValueAndValidity()\n *   C->>NFS: getFormData()\n *   NFS->>AF: Get control values\n *   NFS-->>C: Return form data\n */\nexport class NgxFormService {\n  /**\n   * @description WeakMap that stores control properties for form controls.\n   * @summary A WeakMap that associates AbstractControl instances with their corresponding FieldProperties.\n   * This allows the service to track metadata for form controls without creating memory leaks.\n   *\n   * @type {WeakMap<AbstractControl, FieldProperties>}\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static controls = new WeakMap<AbstractControl, FieldProperties>();\n\n  /**\n   * @description Registry of form groups indexed by their unique identifiers.\n   * @summary A Map that stores FormGroup instances with their unique string identifiers.\n   * This allows global access to registered forms throughout the application.\n   *\n   * @type {Map<string, FormGroup>}\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static formRegistry = new Map<string, FormGroup>();\n  /**\n   * @description Adds a form to the registry.\n   * @summary Registers a FormGroup with a unique identifier. Throws an error if the identifier is already in use.\n   * @param {string} formId - The unique identifier for the form.\n   * @param {FormGroup} formGroup - The FormGroup to be registered.\n   * @throws {Error} If a FormGroup with the given id is already registered.\n   */\n  static addRegistry(formId: string, formGroup: FormGroup): void {\n    if (this.formRegistry.has(formId))\n      throw new Error(`A FormGroup with id '${formId}' is already registered.`);\n    this.formRegistry.set(formId, formGroup);\n  }\n\n  /**\n   * @description Removes a form from the registry.\n   * @summary Deletes a FormGroup from the registry using its unique identifier.\n   * @param {string} formId - The unique identifier of the form to be removed.\n   */\n  static removeRegistry(formId: string): void {\n    this.formRegistry.delete(formId);\n  }\n\n  /**\n   * @description Resolves the parent group and control name from a path.\n   * @summary Traverses the form group structure to find the parent group and control name for a given path.\n   * @param {FormGroup} formGroup - The root FormGroup.\n   * @param {string} path - The path to the control.\n   * @return {FormParentGroup} A tuple containing the parent FormGroup and the control name.\n   */\n  private static resolveParentGroup(formGroup: FormGroup, path: string, componentProps: IComponentInput, parentProps: KeyValue): FormParentGroup {\n    const isMultiple = parentProps?.['multiple'] || parentProps?.['type'] === 'Array' || false;\n    const parts = path.split('.');\n    const controlName = parts.pop() as string;\n    const {childOf} = componentProps\n    let currentGroup = formGroup;\n\n    function setArrayComponentProps(formGroupArray: FormArray) {\n      const props = (formGroupArray as KeyValue)[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] || {};\n        if(!props[ModelKeys.MODEL][controlName])\n          props[ModelKeys.MODEL] = Object.assign({}, props[ModelKeys.MODEL], {[controlName]: {...componentProps}});\n    }\n\n    for (const part of parts) {\n      if (!currentGroup.get(part)) {\n        const partFormGroup = (isMultiple && part === childOf) ? new FormArray([new FormGroup({})]) : new FormGroup({});\n        (partFormGroup as KeyValue)[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] = {\n          childOf: childOf || '',\n          isMultiple: isMultiple,\n          name: part,\n          pk: componentProps?.['pk'] || parentProps?.['pk'] || '',\n          [ModelKeys.MODEL]: {},\n        } as Partial<FieldProperties> & {model: KeyValue};\n\n        if(currentGroup instanceof FormArray) {\n          (currentGroup as FormArray).push(partFormGroup);\n        } else {\n\n          for(const control of Object.values(partFormGroup.controls)) {\n            if(control instanceof FormControl)\n              this.register(control as AbstractControl, componentProps);\n          }\n\n          if(partFormGroup instanceof AbstractControl)\n            this.register(partFormGroup as AbstractControl, componentProps);\n\n          currentGroup.addControl(part, partFormGroup);\n        }\n      }\n      if(childOf && currentGroup instanceof FormArray)\n        setArrayComponentProps(currentGroup);\n\n      currentGroup = currentGroup.get(part) as FormGroup;\n    }\n    return [currentGroup, controlName];\n  }\n\n  /**\n   * @description Retrieves component properties from a FormGroup or FormArray.\n   * @summary Extracts component properties stored in the form group metadata. If a FormGroup is provided\n   * and groupArrayName is specified, it will look for the FormArray within the form structure.\n   *\n   * @param {FormGroup | FormArray} formGroup - The form group or form array to extract properties from\n   * @param {string} [key] - Optional key to retrieve a specific property\n   * @param {string} [groupArrayName] - Optional name of the group array if formGroup is not a FormArray\n   * @return {Partial<FieldProperties>} The component properties or a specific property if key is provided\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getComponentPropsFromGroupArray(formGroup: FormGroup | FormArray, key?: string, groupArrayName?: string | undefined): Partial<FieldProperties> {\n    if(!(formGroup instanceof FormArray) && typeof groupArrayName === Primitives.STRING)\n      formGroup = formGroup.root.get(groupArrayName as string) as FormArray || {};\n    const props = (formGroup as KeyValue)?.[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] || {};\n    return (!key ? props : props?.[key]) || {};\n  }\n\n  /**\n   * @description Adds a new group to a parent FormArray.\n   * @summary Creates and adds a new FormGroup to the specified parent FormArray based on the\n   * component properties stored in the parent's metadata. This is used for dynamic form arrays\n   * where new groups need to be added at runtime.\n   *\n   * @param {FormGroup} formGroup - The root form group containing the parent FormArray\n   * @param {string} parentName - The name of the parent FormArray to add the group to\n   * @param {number} [index=1] - The index position where the new group should be added\n   * @return {FormGroup} The newly created and added FormGroup\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static addGroupToParent(formGroup: FormGroup, parentName: string, index: number = 1): FormGroup {\n    const componentProps = this.getComponentPropsFromGroupArray(formGroup, ModelKeys.MODEL, parentName);\n    Object.entries(componentProps as KeyValue).forEach(([, value]) => {\n      return this.addFormControl(formGroup, value, {multiple: true}, index);\n    });\n\n    return this.getGroupFromParent(formGroup, parentName, index);\n  }\n\n  /**\n   * @description Retrieves a FormGroup from a parent FormArray at the specified index.\n   * @summary Gets a FormGroup from the specified parent FormArray. If the group doesn't exist\n   * at the given index, it will create a new one using addGroupToParent.\n   *\n   * @param {FormGroup} formGroup - The root form group containing the parent FormArray\n   * @param {string} parentName - The name of the parent FormArray to retrieve the group from\n   * @param {number} [index=1] - The index of the group to retrieve\n   * @return {FormGroup} The FormGroup at the specified index\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getGroupFromParent(formGroup: FormGroup, parentName: string, index: number = 1): FormGroup {\n    const childGroup = ((formGroup.get(parentName) || formGroup) as FormArray).at(index);\n    if(childGroup instanceof FormGroup)\n      return childGroup;\n    return this.addGroupToParent(formGroup, parentName, index);\n  }\n\n  /**\n   * @description Checks if a value is unique within a FormArray group.\n   * @summary Validates that the primary key value in a FormGroup is unique among all groups\n   * in the parent FormArray. The uniqueness check behavior differs based on the operation type.\n   *\n   * @param {FormGroup} formGroup - The FormGroup to check for uniqueness\n   * @param {number} index - The index of the current group within the FormArray\n   * @param {OperationKeys} [operation=OperationKeys.CREATE] - The type of operation being performed\n   * @return {boolean} True if the value is unique, false otherwise\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static isUniqueOnGroup(formGroup: FormGroup, index: number, operation: OperationKeys = OperationKeys.CREATE): boolean {\n    const formGroupArray = formGroup.parent as FormArray;\n    const pk = this.getComponentPropsFromGroupArray(formGroupArray, BaseComponentProps.PK as string) as string;\n    const controlName = Object.keys(formGroup.controls)[0];\n\n    // only check for unique if is the pk control\n    if(controlName !== pk)\n      return true;\n    const controlValue = cleanSpaces(`${formGroup.get(pk)?.value}`, true);\n    if(operation === OperationKeys.CREATE)\n      return !formGroupArray.controls.some((group, i) => i !== index && cleanSpaces(`${group.get(pk)?.value}`, true) === controlValue);\n\n    return !formGroupArray.controls.some((group, i) => {\n      const value = cleanSpaces(`${group.get(pk)?.value}`, true);\n      return i !== index && controlValue === value;\n    });\n  }\n\n  /**\n   * @description Enables all controls within a FormGroup or FormArray.\n   * @summary Recursively enables all form controls within the provided FormGroup or FormArray.\n   * This is useful for making all controls interactive after they have been disabled.\n   *\n   * @param {FormArray | FormGroup} formGroup - The FormGroup or FormArray to enable all controls for\n   * @return {void}\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static enableAllGroupControls(formGroup: FormArray | FormGroup): void {\n    Object.keys(formGroup.controls).forEach(key => {\n      const control = formGroup.get(key);\n      if (control instanceof FormArray) {\n        control.controls.forEach(child => {\n          if (child instanceof FormGroup) {\n            child.enable({ emitEvent: false });\n            child.updateValueAndValidity({ emitEvent: true });\n          }\n        });\n      }\n    });\n  }\n\n  /**\n   * @description Adds a form control to a form group based on component properties.\n   * @summary Creates and configures a FormControl within the specified FormGroup using the provided\n   * component properties. Handles nested paths, multiple controls (FormArrays), and control registration.\n   * This method supports complex form structures with nested groups and arrays.\n   *\n   * @param {FormGroup} formGroup - The form group to add the control to\n   * @param {IComponentInput} componentProps - The component properties defining the control configuration\n   * @param {KeyValue} [parentProps={}] - Properties from the parent component for context\n   * @param {number} [index=0] - The index for multiple controls in FormArrays\n   * @return {void}\n   *\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static addFormControl(formGroup: FormGroup, componentProps: IComponentInput, parentProps: KeyValue = {}, index: number = 0): void {\n\n    const isMultiple = parentProps?.['multiple'] || parentProps?.['type'] === 'Array' || false;\n    const { name, childOf, } = componentProps;\n    if(isMultiple)\n      componentProps['pk'] = componentProps['pk'] || parentProps?.['pk'] || '';\n    const fullPath = childOf ? isMultiple ? `${childOf}.${index}.${name}` : `${childOf}.${name}` : name;\n    const [parentGroup, controlName] = this.resolveParentGroup(formGroup, fullPath, componentProps, parentProps);\n\n    if (!parentGroup.get(controlName)) {\n      const control = NgxFormService.fromProps(\n        componentProps,\n        componentProps.updateMode || 'change',\n      );\n      NgxFormService.register(control, componentProps);\n      parentGroup.addControl(controlName, control);\n    }\n\n    componentProps['formGroup'] = parentGroup;\n    componentProps['formControl'] = parentGroup.get(controlName) as FormControl;\n    componentProps['multiple'] = isMultiple\n\n  }\n\n  /**\n   * @description Retrieves a control from a registered form.\n   * @summary Finds and returns an AbstractControl from a registered form using the form id and optional path.\n   * @param {string} formId - The unique identifier of the form.\n   * @param {string} [path] - The path to the control within the form.\n   * @return {AbstractControl} The requested AbstractControl.\n   * @throws {Error} If the form is not found in the registry or the control is not found in the form.\n   */\n  static getControlFromForm(formId: string, path?: string): AbstractControl {\n    const form = this.formRegistry.get(formId);\n    if (!form)\n      throw new Error(`Form with id '${formId}' not found in the registry.`);\n\n    if (!path)\n      return form;\n\n    const control = form.get(path);\n    if (!control)\n      throw new Error(`Control with path '${path}' not found in form '${formId}'.`);\n    return control;\n  }\n\n  /**\n   * @description Creates a form from component configurations.\n   * @summary Generates a FormGroup based on an array of component configurations and optionally registers it.\n   * @param {string} id - The unique identifier for the form.\n   * @param {IComponentConfig[]} components - An array of component configurations.\n   * @param {boolean} [registry=false] - Whether to register the created form.\n   * @return {FormGroup} The created FormGroup.\n   */\n  static createFormFromComponents(id: string, components: IComponentConfig[], registry: boolean = false): FormGroup {\n    const form = new FormGroup({});\n    components.forEach(component => {\n      this.addFormControl(form, component.inputs);\n    });\n\n    if (registry)\n      this.addRegistry(id, form);\n\n    return form;\n  }\n\n  /**\n   * @description Adds a control to a form based on component properties.\n   * @summary Creates and adds a form control to a form (existing or new) based on the provided component properties.\n   * @param {string} id - The unique identifier of the form.\n   * @param {FieldProperties} componentProperties - The properties of the component to create the control from.\n   * @return {AbstractControl} The form or created control.\n   */\n  static addControlFromProps(id: string, componentProperties: FieldProperties, parentProps?: FieldProperties): AbstractControl {\n    const form = this.formRegistry.get(id) ?? new FormGroup({});\n    if (!this.formRegistry.has(id))\n      this.addRegistry(id, form);\n\n    if (componentProperties.path)\n      this.addFormControl(form, componentProperties, parentProps);\n\n    return form;\n  }\n\n  /**\n   * @description Retrieves form data from a FormGroup.\n   * @summary Extracts and processes the data from a FormGroup, handling different input types and nested form groups.\n   * @param {FormGroup} formGroup - The FormGroup to extract data from.\n   * @return {Record<string, unknown>} An object containing the form data.\n   */\n  static getFormData(formGroup: FormGroup): Record<string, unknown> {\n    const data: Record<string, unknown> = {};\n    for (const key in formGroup.controls) {\n      const control = formGroup.controls[key];\n      const parentProps = NgxFormService.getPropsFromControl(formGroup as FormGroup | FormArray);\n      if (!(control instanceof FormControl)) {\n        const value = NgxFormService.getFormData(control as FormGroup);\n        const isValid = control.valid;\n        if(parentProps.multiple) {\n            if(isValid) {\n               data[key] = value;\n            } else {\n              this.reset(control as FormControl);\n            }\n\n            continue;\n        }\n        data[key] = value;\n        continue;\n      }\n\n      const props = NgxFormService.getPropsFromControl(control as FormControl | FormArray);\n      let value = control.value;\n      if (!HTML5CheckTypes.includes(props['type'])) {\n        switch (props['type']) {\n          case HTML5InputTypes.NUMBER:\n            value = parseToNumber(value);\n            break;\n          case HTML5InputTypes.DATE:\n          case HTML5InputTypes.DATETIME_LOCAL:\n            value = new Date(value);\n            break;\n          default:\n            value = escapeHtml(value);\n        }\n      }\n      data[key] = value;\n    }\n    NgxFormService.enableAllGroupControls(formGroup as FormGroup);\n    return data;\n  }\n\n  /**\n   * @description Validates fields in a form control or form group.\n   * @summary Recursively validates all fields in a form control or form group, marking them as touched and dirty.\n   * @param {AbstractControl} control - The control or form group to validate.\n   * @param {string} [path] - The path to the control within the form.\n   * @return {boolean} True if all fields are valid, false otherwise.\n   * @throws {Error} If no control is found at the specified path or if the control type is unknown.\n   */\n  static validateFields(control: AbstractControl, pk?: string,  path?: string): boolean {\n    control = path ? control.get(path) as AbstractControl : control;\n    if (!control)\n      throw new Error(`No control found at path: ${path || 'root'}.`);\n\n    const isAllowed = [FormArray, FormGroup, FormControl].some(type => control instanceof type);\n    if (!isAllowed)\n      throw new Error(`Unknown control type at: ${path || 'root'}`);\n\n    control.markAsTouched();\n    control.markAsDirty();\n    control.updateValueAndValidity({ emitEvent: true });\n\n    if (control instanceof FormGroup) {\n      Object.values(control.controls).forEach(childControl => {\n        this.validateFields(childControl);\n      });\n    }\n\n    if (control instanceof FormArray) {\n      const totalGroups = control.length;\n      const hasValid = control.controls.some(control => control.valid);\n      if(totalGroups > 1 && hasValid) {\n         for (let i = control.length - 1; i >= 0; i--) {\n          const childControl = control.at(i);\n          // disable no valid groups on array\n          if (!childControl.valid) {\n            (childControl.parent as FormGroup).setErrors(null);\n             (childControl.parent as FormGroup).updateValueAndValidity({ emitEvent: true });\n            childControl.disable();\n          } else {\n            this.validateFields(childControl);\n          }\n        }\n      } else {\n        Object.values(control.controls).forEach(childControl => {\n          this.validateFields(childControl);\n        });\n      }\n    }\n\n    function getControlName(control: AbstractControl): string | null {\n      const group = control.parent as FormGroup;\n      if (!group)\n          return null;\n      return Object.keys(group.controls).find(name => control === group.get(name)) || null;\n    }\n\n    return !getControlName(control) ? true : control.valid;\n  }\n\n  /**\n   * @description Generates validators from component properties.\n   * @summary Creates an array of ValidatorFn based on the supported validation keys in the component properties.\n   * @param {FieldProperties} props - The component properties.\n   * @return {ValidatorFn[]} An array of validator functions.\n   */\n  private static validatorsFromProps(props: FieldProperties): ValidatorFn[] {\n    const supportedValidationKeys = Validation.keys();\n    return Object.keys(props)\n      .filter((k: string) => supportedValidationKeys.includes(k))\n      .map((k: string) => {\n        return ValidatorFactory.spawn(props, k);\n      });\n  }\n\n  /**\n   * @description Creates a FormControl from component properties.\n   * @summary Generates a FormControl with validators based on the provided component properties.\n   * @param {FieldProperties} props - The component properties.\n   * @param {FieldUpdateMode} [updateMode='change'] - The update mode for the control.\n   * @return {FormControl} The created FormControl.\n   */\n  static fromProps(props: FieldProperties, updateMode: FieldUpdateMode = 'change'): FormControl {\n    const validators = this.validatorsFromProps(props);\n    const composed = validators.length ? Validators.compose(validators) : null;\n    return new FormControl(\n      {\n        value:\n          props.value && props.type !== HTML5InputTypes.CHECKBOX\n            ? props.type === HTML5InputTypes.DATE\n              ? !isValidDate(parseDate(props.format as string, props.value as string))\n                ? undefined : props.value :\n              (props.value as unknown) : undefined,\n        disabled: props.disabled,\n      },\n      {\n        validators: composed,\n        updateOn: updateMode,\n      },\n    );\n  }\n\n  /**\n   * @description Retrieves properties from a FormControl.\n   * @summary Gets the FieldProperties associated with a FormControl from the internal WeakMap.\n   * @param {FormControl} control - The FormControl to get properties for.\n   * @return {FieldProperties} The properties associated with the control.\n   */\n  static getPropsFromControl(control: FormControl | FormArray | FormGroup): FieldProperties {\n    return this.controls.get(control) || {} as FieldProperties;\n  }\n\n  /**\n   * @description Finds a parent element with a specific tag.\n   * @summary Traverses up the DOM tree to find the nearest parent element with the specified tag.\n   * @param {HTMLElement} el - The starting element.\n   * @param {string} tag - The tag name to search for.\n   * @return {HTMLElement} The found parent element.\n   * @throws {Error} If no parent with the specified tag is found.\n   */\n  static getParentEl(el: HTMLElement, tag: string): HTMLElement {\n    let parent: HTMLElement | null;\n    while ((parent = el.parentElement) !== null) {\n      if (parent.tagName.toLowerCase() === tag.toLowerCase()) {\n        return parent;\n      }\n      el = parent;\n    }\n    throw new Error(\n      `No parent with the tag ${tag} was found for provided element`,\n    );\n  }\n\n  /**\n   * @description Registers a control with its properties.\n   * @summary Associates a control with its properties in the internal WeakMap.\n   * @param {AbstractControl} control - The control to register.\n   * @param {FieldProperties} props - The properties to associate with the control.\n   */\n  static register(control: AbstractControl, props: FieldProperties) {\n    this.controls.set(control, props);\n  }\n\n  /**\n   * @description Unregisters a control.\n   * @summary Removes a control and its associated properties from the internal WeakMap.\n   * @param {AbstractControl} control - The control to unregister.\n   * @return {boolean} True if the control was successfully unregistered, false otherwise.\n   */\n  static unregister(control: AbstractControl): boolean {\n    return this.controls.delete(control);\n  }\n\n  /**\n   * @description Resets a form group.\n   * @summary Recursively resets all controls in a form group, clearing values, errors, and marking them as pristine and untouched.\n   * @param {FormGroup} formGroup - The form group to reset.\n   */\n  static reset(formGroup: FormGroup | FormControl): void {\n    if(formGroup instanceof FormControl) {\n      const control = formGroup as FormControl;\n      const { type } = NgxFormService.getPropsFromControl(control);\n      if (!HTML5CheckTypes.includes(type))\n        control.setValue(\"\");\n      control.markAsPristine();\n      control.markAsUntouched();\n      control.setErrors(null);\n      control.updateValueAndValidity();\n    } else {\n      for (const key in formGroup.controls) {\n        const control = formGroup.controls[key];\n        NgxFormService.reset(control as FormControl);\n        continue;\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxFormService.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxFormService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,eAAe,EAAE,eAAe,EAAE,aAAa,EAAmB,MAAM,yBAAyB,CAAC;AAGxI,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAe,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC3G,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;;;;OASG;aACY,aAAQ,GAA8C,IAAI,OAAO,EAAoC,CAAC;IAErH;;;;;;;;;OASG;aACY,iBAAY,GAA4B,IAAI,GAAG,EAAsB,CAAC;aAEtE,eAAU,GAAa,EAAE,CAAC;IAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,UAAU,CAAC,EAAU,EAAE,QAAkC,EAAE,EAAE,WAAoB,IAAI;QAC1F,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,KAAK,EAAE,KAAK,GAAI,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;QACtH,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,QAAQ;YACxC,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,IAA6B,CAAC,CAAC;QACtD,OAAO,IAA6B,CAAC;IACvC,CAAC;IAGD;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,WAAW,CAAC,MAAc,EAAE,SAAqB;QACtD,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,wBAAwB,MAAM,0BAA0B,CAAC,CAAC;QAC5E,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,cAAc,CAAC,MAAc;QAClC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACK,MAAM,CAAC,kBAAkB,CAAC,SAAoB,EAAE,IAAY,EAAE,cAA+B,EAAE,WAAqB;QAC1H,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC,UAAU,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,OAAO,IAAI,KAAK,CAAC;QAC3F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,EAAY,CAAC;QAC1C,MAAM,EAAC,OAAO,EAAC,GAAG,cAAc,CAAA;QAChC,IAAI,YAAY,GAAG,SAAS,CAAC;QAE7B,SAAS,sBAAsB,CAAC,cAAyB;YACvD,MAAM,KAAK,GAAI,cAA2B,CAAC,iBAAiB,CAAC,0BAA0B,CAAC,IAAI,EAAE,CAAC;YAC7F,IAAG,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC;gBACrC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAC,CAAC,WAAW,CAAC,EAAE,EAAC,GAAG,cAAc,EAAC,EAAC,CAAC,CAAC;QAC/G,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5B,MAAM,aAAa,GAAG,CAAC,UAAU,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;gBAC/G,aAA0B,CAAC,iBAAiB,CAAC,0BAA0B,CAAC,GAAG;oBAC1E,OAAO,EAAE,OAAO,IAAI,EAAE;oBACtB,UAAU,EAAE,UAAU;oBACtB,IAAI,EAAE,IAAI;oBACV,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE;oBACvD,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE;iBAC0B,CAAC;gBAElD,IAAG,YAAY,YAAY,SAAS,EAAE,CAAC;oBACpC,YAA0B,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBAClD,CAAC;qBAAM,CAAC;oBAEN,KAAI,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC3D,IAAG,OAAO,YAAY,WAAW;4BAC/B,IAAI,CAAC,QAAQ,CAAC,OAA0B,EAAE,cAAc,CAAC,CAAC;oBAC9D,CAAC;oBAED,IAAG,aAAa,YAAY,eAAe;wBACzC,IAAI,CAAC,QAAQ,CAAC,aAAgC,EAAE,cAAc,CAAC,CAAC;oBAElE,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC;YACD,IAAG,OAAO,IAAI,YAAY,YAAY,SAAS;gBAC7C,sBAAsB,CAAC,YAAY,CAAC,CAAC;YAEvC,YAAY,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAc,CAAC;QACrD,CAAC;QACD,OAAO,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,+BAA+B,CAAC,SAAgC,EAAE,GAAY,EAAE,cAAmC;QACxH,IAAG,CAAC,CAAC,SAAS,YAAY,SAAS,CAAC,IAAI,OAAO,cAAc,KAAK,UAAU,CAAC,MAAM;YACjF,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,cAAwB,CAAc,IAAI,EAAE,CAAC;QAC9E,MAAM,KAAK,GAAI,SAAsB,EAAE,CAAC,iBAAiB,CAAC,0BAA0B,CAAC,IAAI,EAAE,CAAC;QAC5F,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,gBAAgB,CAAC,SAAoB,EAAE,UAAkB,EAAE,QAAgB,CAAC;QACjF,MAAM,cAAc,GAAG,IAAI,CAAC,+BAA+B,CAAC,SAAS,EAAE,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QACpG,MAAM,CAAC,OAAO,CAAC,cAA0B,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE;YAC/D,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,KAAK,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,EAAE,KAAK,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,kBAAkB,CAAC,SAAoB,EAAE,UAAkB,EAAE,QAAgB,CAAC;QACnF,MAAM,UAAU,GAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,SAAS,CAAe,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACrF,IAAG,UAAU,YAAY,SAAS;YAChC,OAAO,UAAU,CAAC;QACpB,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,eAAe,CAAC,SAAoB,EAAE,KAAa,EAAE,YAA2B,aAAa,CAAC,MAAM;QACzG,MAAM,cAAc,GAAG,SAAS,CAAC,MAAmB,CAAC;QACrD,MAAM,EAAE,GAAG,IAAI,CAAC,+BAA+B,CAAC,cAAc,EAAE,kBAAkB,CAAC,EAAY,CAAW,CAAC;QAC3G,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAEvD,6CAA6C;QAC7C,IAAG,WAAW,KAAK,EAAE;YACnB,OAAO,IAAI,CAAC;QACd,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC;QACtE,IAAG,SAAS,KAAK,aAAa,CAAC,MAAM;YACnC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,IAAI,WAAW,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,KAAK,YAAY,CAAC,CAAC;QAEnI,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YAChD,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC;YAC3D,OAAO,CAAC,KAAK,KAAK,IAAI,YAAY,KAAK,KAAK,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,sBAAsB,CAAC,SAAgC;QAC5D,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAC5C,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACnC,IAAI,OAAO,YAAY,SAAS,EAAE,CAAC;gBACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;oBAC/B,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;wBAC/B,KAAK,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;wBACnC,KAAK,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;oBACpD,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACK,MAAM,CAAC,cAAc,CAAC,SAAqB,EAAE,cAA+B,EAAE,cAAwB,EAAE,EAAE,QAAgB,CAAC;QAEjI,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC,UAAU,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,OAAO,IAAI,KAAK,CAAC;QAC3F,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,GAAG,cAAc,CAAC;QAC1C,IAAG,UAAU;YACX,cAAc,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC3E,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACpG,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAsB,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;QAE1H,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YAClC,MAAM,OAAO,GAAG,cAAc,CAAC,SAAS,CACtC,cAAc,EACd,cAAc,CAAC,UAAU,IAAI,QAAQ,CACtC,CAAC;YACF,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YACjD,IAAI,WAAW,YAAY,SAAS,EAAE,CAAC;gBACrC,WAAW,CAAC,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAC/C,CAAC;YACD,IAAG,WAAW,YAAY,SAAS,EAAE,CAAC;gBACpC,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAE,cAA2B,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAc,CAAC;gBAC3F,IAAG,IAAI,EAAE,CAAC;oBACP,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBACzC,CAAC;qBAAM,CAAC;oBACN,WAAW,CAAC,IAAI,CAAC,EAAC,CAAC,WAAW,CAAC,EAAE,OAAO,EAAC,CAAC,CAAC;gBAC7C,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,IAAI,GAAG,WAAW,YAAY,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAE,cAA2B,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAC/H,cAAc,CAAC,WAAW,CAAC,GAAG,IAAiB,CAAC;QAChD,cAAc,CAAC,aAAa,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,WAAW,CAAgB,CAAC;QAC5E,cAAc,CAAC,UAAU,CAAC,GAAG,UAAU,CAAA;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAc,EAAE,IAAa;QACrD,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI;YACP,MAAM,IAAI,KAAK,CAAC,iBAAiB,MAAM,8BAA8B,CAAC,CAAC;QAEzE,IAAI,CAAC,IAAI;YACP,OAAO,IAAI,CAAC;QAEd,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,OAAO;YACV,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,wBAAwB,MAAM,IAAI,CAAC,CAAC;QAChF,OAAO,OAAO,CAAC;IACjB,CAAC;IAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,sBAAsB,CAAC,EAAU,EAAE,WAAoB,KAAK,EAAG,QAA4B;QAChG,MAAM,IAAI,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;QAC/B,IAAG,QAAQ,EAAE,MAAM;YACjB,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACvB,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,KAAwB,CAAC,CAAC;YAC5D,CAAC,CAAC,CAAC;QACL,IAAI,QAAQ;YACV,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,wBAAwB,CAAC,EAAU,EAAE,UAA8B,EAAE,WAAoB,KAAK;QACnG,MAAM,IAAI,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;QAC/B,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,IAAI,QAAQ;YACV,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAE7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,MAAM,CAAC,mBAAmB,CAAC,EAAU,EAAE,mBAAoC,EAAE,WAA6B;QACxG,IAAI,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QAClD,MAAM,UAAU,GAAI,IAAkB,CAAC,MAAM,CAAC;QAC9C,IAAG,WAAW,EAAE,KAAK,IAAI,WAAW,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC;YAChD,IAAI,KAAK,GAAG,mBAAmB,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC;YACzD,IAAG,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,KAAK,KAAK,CAAC;gBAC5C,MAAM,KAAK,CAAC,sDAAsD,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC;YAEhG,IAAG,KAAK,GAAG,UAAU,EAAE,CAAC;gBACtB,IAAI,IAAiB,EAAE,CAAC,WAAW,CAAC,IAAI,KAAK,KAAM,IAAiB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1F,KAAK,GAAI,IAAiB,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC;gBACnD,CAAC;qBAAM,CAAC;oBACL,IAAiB,CAAC,WAAW,CAAC,GAAG;wBAChC,IAAI,EAAE,KAAK;wBACX,KAAK,EAAE,UAAU,GAAG,CAAC;qBACtB,CAAC;oBACF,KAAK,GAAG,UAAU,GAAG,CAAC,CAAC;gBACzB,CAAC;YACH,CAAC;YAED,IAAI,KAAK,GAAI,IAAkB,CAAC,QAAQ,CAAE,KAAgB,GAAG,CAAC,CAAC,CAAC;YAChE,IAAG,CAAC,KAAK,EAAE,CAAC;gBACV,KAAK,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;gBACzB,IAAkB,CAAC,MAAM,CAAC,KAAe,EAAE,KAAK,CAAC,CAAC;YACrD,CAAC;YACD,IAAI,GAAG,KAAkB,CAAC;QAC5B,CAAC;QACD,IAAG,mBAAmB,CAAC,IAAI;YACzB,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,mBAAmB,EAAE,WAAW,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,MAAM,CAAC,WAAW,CAAC,SAAoB;QACrC,MAAM,IAAI,GAA4B,EAAE,CAAC;QACzC,KAAK,MAAM,GAAG,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACxC,MAAM,WAAW,GAAG,cAAc,CAAC,mBAAmB,CAAC,SAAkC,CAAC,CAAC;YAC3F,IAAI,CAAC,CAAC,OAAO,YAAY,WAAW,CAAC,EAAE,CAAC;gBACtC,MAAM,KAAK,GAAG,cAAc,CAAC,WAAW,CAAC,OAAoB,CAAC,CAAC;gBAC/D,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;gBAC9B,IAAG,WAAW,CAAC,QAAQ,EAAE,CAAC;oBACtB,IAAG,OAAO,EAAE,CAAC;wBACV,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;oBACrB,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,KAAK,CAAC,OAAsB,CAAC,CAAC;oBACrC,CAAC;oBAED,SAAS;gBACb,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBAClB,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GAAG,cAAc,CAAC,mBAAmB,CAAC,OAAkC,CAAC,CAAC;YACrF,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBAC7C,QAAQ,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;oBACtB,KAAK,eAAe,CAAC,MAAM;wBACzB,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;wBAC7B,MAAM;oBACR,KAAK,eAAe,CAAC,IAAI,CAAC;oBAC1B,KAAK,eAAe,CAAC,cAAc;wBACjC,KAAK,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;wBACxB,MAAM;oBACR;wBACE,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;gBAC9B,CAAC;YACH,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACpB,CAAC;QACD,cAAc,CAAC,sBAAsB,CAAC,SAAsB,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,MAAM,CAAC,cAAc,CAAC,OAAwB,EAAE,EAAW,EAAG,IAAa;QACzE,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAoB,CAAC,CAAC,CAAC,OAAO,CAAC;QAChE,IAAI,CAAC,OAAO;YACV,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,IAAI,MAAM,GAAG,CAAC,CAAC;QAElE,MAAM,SAAS,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,YAAY,IAAI,CAAC,CAAC;QAC5F,IAAI,CAAC,SAAS;YACZ,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,IAAI,MAAM,EAAE,CAAC,CAAC;QAEhE,OAAO,CAAC,aAAa,EAAE,CAAC;QACxB,OAAO,CAAC,WAAW,EAAE,CAAC;QACtB,OAAO,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAEpD,IAAI,OAAO,YAAY,SAAS,EAAE,CAAC;YACjC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;gBACrD,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,YAAY,SAAS,EAAE,CAAC;YACjC,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;YACnC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACjE,IAAG,WAAW,GAAG,CAAC,IAAI,QAAQ,EAAE,CAAC;gBAC9B,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC9C,MAAM,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;oBACnC,mCAAmC;oBACnC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;wBACvB,YAAY,CAAC,MAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;wBACjD,YAAY,CAAC,MAAoB,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;wBAChF,YAAY,CAAC,OAAO,EAAE,CAAC;oBACzB,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;oBACpC,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;oBACrD,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;gBACpC,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,qEAAqE;QACrE,+CAA+C;QAC/C,gBAAgB;QAChB,qBAAqB;QACrB,0FAA0F;QAC1F,IAAI;QAEJ,OAAO,OAAO,CAAC,KAAK,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACK,MAAM,CAAC,mBAAmB,CAAC,KAAsB;QACvD,MAAM,uBAAuB,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;QAClD,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;aACtB,MAAM,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;aAC1D,GAAG,CAAC,CAAC,CAAS,EAAE,EAAE;YACjB,OAAO,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,SAAS,CAAC,KAAsB,EAAE,aAA8B,QAAQ;QAC7E,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3E,OAAO,IAAI,WAAW,CACpB;YACE,KAAK,EACH,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe,CAAC,QAAQ;gBACpD,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI;oBACnC,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,MAAgB,EAAE,KAAK,CAAC,KAAe,CAAC,CAAC;wBACtE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAC5B,KAAK,CAAC,KAAiB,CAAC,CAAC,CAAC,SAAS;YAC1C,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,EACD;YACE,UAAU,EAAE,QAAQ;YACpB,QAAQ,EAAE,UAAU;SACrB,CACF,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAA4C;QACrE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAqB,CAAC;IAC7D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,WAAW,CAAC,EAAe,EAAE,GAAW;QAC7C,IAAI,MAA0B,CAAC;QAC/B,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE,CAAC;YAC5C,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,WAAW,EAAE,EAAE,CAAC;gBACvD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,EAAE,GAAG,MAAM,CAAC;QACd,CAAC;QACD,MAAM,IAAI,KAAK,CACb,0BAA0B,GAAG,iCAAiC,CAC/D,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAwB,EAAE,KAAsB;QAC9D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,OAAwB;QACxC,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,SAAkC;QAC7C,IAAG,SAAS,YAAY,WAAW,EAAE,CAAC;YACpC,MAAM,OAAO,GAAG,SAAwB,CAAC;YACzC,MAAM,EAAE,IAAI,EAAE,GAAG,cAAc,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YAC7D,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACjC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACvB,OAAO,CAAC,cAAc,EAAE,CAAC;YACzB,OAAO,CAAC,eAAe,EAAE,CAAC;YAC1B,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACxB,OAAO,CAAC,sBAAsB,EAAE,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,KAAK,MAAM,GAAG,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACrC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBACxC,cAAc,CAAC,KAAK,CAAC,OAAsB,CAAC,CAAC;gBAC7C,SAAS;YACX,CAAC;QACH,CAAC;IACH,CAAC","sourcesContent":["import { escapeHtml, FieldProperties, HTML5CheckTypes, HTML5InputTypes, parseToNumber, UIModelMetadata } from '@decaf-ts/ui-decorators';\nimport { FieldUpdateMode, FormParent, FormParentGroup, KeyValue } from './types';\nimport { IComponentConfig, IComponentInput } from './interfaces';\nimport { AbstractControl, FormArray, FormControl, FormGroup, ValidatorFn, Validators } from '@angular/forms';\nimport { isValidDate, ModelKeys, parseDate, Primitives, Validation } from '@decaf-ts/decorator-validation';\nimport { ValidatorFactory } from './ValidatorFactory';\nimport { cleanSpaces } from '../helpers';\nimport { OperationKeys } from '@decaf-ts/db-decorators';\nimport { AngularEngineKeys, BaseComponentProps } from '../engine/constants';\n\n\n/**\n * @description Service for managing Angular forms and form controls.\n * @summary The NgxFormService provides utility methods for creating, managing, and validating Angular forms and form controls. It includes functionality for registering forms, adding controls, validating fields, and handling form data.\n *\n * @class\n * @param {WeakMap<AbstractControl, FieldProperties>} controls - A WeakMap to store control properties.\n * @param {Map<string, FormGroup>} formRegistry - A Map to store registered forms.\n *\n * @example\n * // Creating a form from components\n * const components = [\n *   { inputs: { name: 'username', type: 'text', required: true } },\n *   { inputs: { name: 'password', type: 'password', minLength: 8 } }\n * ];\n * const form = NgxFormService.createFormFromComponents('loginForm', components, true);\n *\n * // Validating fields\n * NgxFormService.validateFields(form);\n *\n * // Getting form data\n * const formData = NgxFormService.getFormData(form);\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Component\n *   participant NFS as NgxFormService\n *   participant AF as Angular Forms\n *   C->>NFS: createFormFromComponents()\n *   NFS->>AF: new FormGroup()\n *   NFS->>NFS: addFormControl()\n *   NFS->>AF: addControl()\n *   NFS-->>C: Return FormGroup\n *   C->>NFS: validateFields()\n *   NFS->>AF: markAsTouched(), markAsDirty(), updateValueAndValidity()\n *   C->>NFS: getFormData()\n *   NFS->>AF: Get control values\n *   NFS-->>C: Return form data\n */\nexport class NgxFormService {\n  /**\n   * @description WeakMap that stores control properties for form controls.\n   * @summary A WeakMap that associates AbstractControl instances with their corresponding FieldProperties.\n   * This allows the service to track metadata for form controls without creating memory leaks.\n   *\n   * @type {WeakMap<AbstractControl, FieldProperties>}\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static controls: WeakMap<AbstractControl, FieldProperties> = new WeakMap<AbstractControl, FieldProperties>();\n\n  /**\n   * @description Registry of form groups indexed by their unique identifiers.\n   * @summary A Map that stores FormGroup instances with their unique string identifiers.\n   * This allows global access to registered forms throughout the application.\n   *\n   * @type {Map<string, FormGroup>}\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static formRegistry: Map<string, FormParent> = new Map<string, FormParent>();\n\n  private static pageMapper: KeyValue = {};\n\n  /**\n   * @description Creates a new form group or form array with the specified identifier.\n   * @summary Generates a FormGroup or FormArray based on the provided properties. If pages are specified\n   * and greater than 1, creates a FormArray; otherwise creates a FormGroup. The form can optionally\n   * be registered in the global form registry for later access throughout the application.\n   *\n   * @param {string} id - Unique identifier for the form\n   * @param {Partial<IComponentInput>} [props={}] - Configuration properties for the form\n   * @param {boolean} [registry=true] - Whether to register the form in the global registry\n   * @return {FormGroup | FormArray} The created form instance\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant FR as Form Registry\n   *   participant AF as Angular Forms\n   *\n   *   C->>NFS: createForm(id, props, registry)\n   *   NFS->>FR: Check if form exists\n   *   alt Form doesn't exist\n   *     alt props.pages > 1\n   *       NFS->>AF: new FormArray([])\n   *     else\n   *       NFS->>AF: new FormGroup({})\n   *     end\n   *     alt registry is true\n   *       NFS->>FR: addRegistry(id, form)\n   *     end\n   *   end\n   *   NFS-->>C: Return FormGroup | FormArray\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static createForm(id: string, props: Partial<IComponentInput> = {}, registry: boolean = true): FormGroup | FormArray {\n    const form = this.formRegistry.get(id) ?? (props?.pages && props?.pages  > 1 ? new FormArray([]) : new FormGroup({}));\n    if (!this.formRegistry.has(id) && registry)\n      this.addRegistry(id, form as FormArray | FormGroup);\n    return form as FormArray | FormGroup;\n  }\n\n\n  /**\n   * @description Adds a form to the registry.\n   * @summary Registers a FormGroup or FormArray with a unique identifier for global access throughout\n   * the application. This allows forms to be retrieved and managed centrally. Throws an error if\n   * the identifier is already in use to prevent conflicts.\n   *\n   * @param {string} formId - The unique identifier for the form\n   * @param {FormParent} formGroup - The FormGroup or FormArray to be registered\n   * @return {void}\n   * @throws {Error} If a FormGroup with the given id is already registered\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static addRegistry(formId: string, formGroup: FormParent): void {\n    if (this.formRegistry.has(formId))\n      throw new Error(`A FormGroup with id '${formId}' is already registered.`);\n    this.formRegistry.set(formId, formGroup);\n  }\n\n  /**\n   * @description Removes a form from the registry.\n   * @summary Deletes a FormGroup or FormArray from the registry using its unique identifier.\n   * This cleans up the registry and allows the identifier to be reused. The form itself\n   * is not destroyed, only removed from the central registry.\n   *\n   * @param {string} formId - The unique identifier of the form to be removed\n   * @return {void}\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static removeRegistry(formId: string): void {\n    this.formRegistry.delete(formId);\n  }\n\n  /**\n   * @description Resolves the parent group and control name from a path.\n   * @summary Traverses the form group structure to find the parent group and control name for a given path.\n   * Handles complex nested structures including arrays and sub-groups. Creates missing intermediate\n   * groups as needed and properly configures FormArray controls for multiple value scenarios.\n   *\n   * @param {FormGroup} formGroup - The root FormGroup to traverse\n   * @param {string} path - The dot-separated path to the control (e.g., 'user.address.street')\n   * @param {IComponentInput} componentProps - Properties defining the component configuration\n   * @param {KeyValue} parentProps - Properties from the parent component for context\n   * @return {FormParentGroup} A tuple containing the parent FormGroup and the control name\n   *\n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant NFS as NgxFormService\n   *   participant FG as FormGroup\n   *   participant FA as FormArray\n   *\n   *   NFS->>NFS: Split path into parts\n   *   loop For each path part\n   *     alt Control doesn't exist\n   *       alt isMultiple and part is childOf\n   *         NFS->>FA: new FormArray([new FormGroup({})])\n   *       else\n   *         NFS->>FG: new FormGroup({})\n   *       end\n   *       NFS->>FG: addControl(part, newControl)\n   *     end\n   *     NFS->>NFS: Navigate to next level\n   *   end\n   *   NFS-->>NFS: Return [parentGroup, controlName]\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static resolveParentGroup(formGroup: FormGroup, path: string, componentProps: IComponentInput, parentProps: KeyValue): FormParentGroup {\n    const isMultiple = parentProps?.['multiple'] || parentProps?.['type'] === 'Array' || false;\n    const parts = path.split('.');\n    const controlName = parts.pop() as string;\n    const {childOf} = componentProps\n    let currentGroup = formGroup;\n\n    function setArrayComponentProps(formGroupArray: FormArray) {\n      const props = (formGroupArray as KeyValue)[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] || {};\n        if(!props[ModelKeys.MODEL][controlName])\n          props[ModelKeys.MODEL] = Object.assign({}, props[ModelKeys.MODEL], {[controlName]: {...componentProps}});\n    }\n\n    for (const part of parts) {\n      if (!currentGroup.get(part)) {\n        const partFormGroup = (isMultiple && part === childOf) ? new FormArray([new FormGroup({})]) : new FormGroup({});\n        (partFormGroup as KeyValue)[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] = {\n          childOf: childOf || '',\n          isMultiple: isMultiple,\n          name: part,\n          pk: componentProps?.['pk'] || parentProps?.['pk'] || '',\n          [ModelKeys.MODEL]: {},\n        } as Partial<FieldProperties> & {model: KeyValue};\n\n        if(currentGroup instanceof FormArray) {\n          (currentGroup as FormArray).push(partFormGroup);\n        } else {\n\n          for(const control of Object.values(partFormGroup.controls)) {\n            if(control instanceof FormControl)\n              this.register(control as AbstractControl, componentProps);\n          }\n\n          if(partFormGroup instanceof AbstractControl)\n            this.register(partFormGroup as AbstractControl, componentProps);\n\n          currentGroup.addControl(part, partFormGroup);\n        }\n      }\n      if(childOf && currentGroup instanceof FormArray)\n        setArrayComponentProps(currentGroup);\n\n      currentGroup = currentGroup.get(part) as FormGroup;\n    }\n    return [currentGroup, controlName];\n  }\n\n  /**\n   * @description Retrieves component properties from a FormGroup or FormArray.\n   * @summary Extracts component properties stored in the form group metadata. If a FormGroup is provided\n   * and groupArrayName is specified, it will look for the FormArray within the form structure.\n   *\n   * @param {FormGroup | FormArray} formGroup - The form group or form array to extract properties from\n   * @param {string} [key] - Optional key to retrieve a specific property\n   * @param {string} [groupArrayName] - Optional name of the group array if formGroup is not a FormArray\n   * @return {Partial<FieldProperties>} The component properties or a specific property if key is provided\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getComponentPropsFromGroupArray(formGroup: FormGroup | FormArray, key?: string, groupArrayName?: string | undefined): Partial<FieldProperties> {\n    if(!(formGroup instanceof FormArray) && typeof groupArrayName === Primitives.STRING)\n      formGroup = formGroup.root.get(groupArrayName as string) as FormArray || {};\n    const props = (formGroup as KeyValue)?.[AngularEngineKeys.FORM_GROUP_COMPONENT_PROPS] || {};\n    return (!key ? props : props?.[key]) || {};\n  }\n\n  /**\n   * @description Adds a new group to a parent FormArray.\n   * @summary Creates and adds a new FormGroup to the specified parent FormArray based on the\n   * component properties stored in the parent's metadata. This is used for dynamic form arrays\n   * where new groups need to be added at runtime.\n   *\n   * @param {FormGroup} formGroup - The root form group containing the parent FormArray\n   * @param {string} parentName - The name of the parent FormArray to add the group to\n   * @param {number} [index=1] - The index position where the new group should be added\n   * @return {FormGroup} The newly created and added FormGroup\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static addGroupToParent(formGroup: FormGroup, parentName: string, index: number = 1): FormGroup {\n    const componentProps = this.getComponentPropsFromGroupArray(formGroup, ModelKeys.MODEL, parentName);\n    Object.entries(componentProps as KeyValue).forEach(([, value]) => {\n      return this.addFormControl(formGroup, value, {multiple: true}, index);\n    });\n\n    return this.getGroupFromParent(formGroup, parentName, index);\n  }\n\n  /**\n   * @description Retrieves a FormGroup from a parent FormArray at the specified index.\n   * @summary Gets a FormGroup from the specified parent FormArray. If the group doesn't exist\n   * at the given index, it will create a new one using addGroupToParent.\n   *\n   * @param {FormGroup} formGroup - The root form group containing the parent FormArray\n   * @param {string} parentName - The name of the parent FormArray to retrieve the group from\n   * @param {number} [index=1] - The index of the group to retrieve\n   * @return {FormGroup} The FormGroup at the specified index\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getGroupFromParent(formGroup: FormGroup, parentName: string, index: number = 1): FormGroup {\n    const childGroup = ((formGroup.get(parentName) || formGroup) as FormArray).at(index);\n    if(childGroup instanceof FormGroup)\n      return childGroup;\n    return this.addGroupToParent(formGroup, parentName, index);\n  }\n\n  /**\n   * @description Checks if a value is unique within a FormArray group.\n   * @summary Validates that the primary key value in a FormGroup is unique among all groups\n   * in the parent FormArray. The uniqueness check behavior differs based on the operation type.\n   *\n   * @param {FormGroup} formGroup - The FormGroup to check for uniqueness\n   * @param {number} index - The index of the current group within the FormArray\n   * @param {OperationKeys} [operation=OperationKeys.CREATE] - The type of operation being performed\n   * @return {boolean} True if the value is unique, false otherwise\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static isUniqueOnGroup(formGroup: FormGroup, index: number, operation: OperationKeys = OperationKeys.CREATE): boolean {\n    const formGroupArray = formGroup.parent as FormArray;\n    const pk = this.getComponentPropsFromGroupArray(formGroupArray, BaseComponentProps.PK as string) as string;\n    const controlName = Object.keys(formGroup.controls)[0];\n\n    // only check for unique if is the pk control\n    if(controlName !== pk)\n      return true;\n    const controlValue = cleanSpaces(`${formGroup.get(pk)?.value}`, true);\n    if(operation === OperationKeys.CREATE)\n      return !formGroupArray.controls.some((group, i) => i !== index && cleanSpaces(`${group.get(pk)?.value}`, true) === controlValue);\n\n    return !formGroupArray.controls.some((group, i) => {\n      const value = cleanSpaces(`${group.get(pk)?.value}`, true);\n      return i !== index && controlValue === value;\n    });\n  }\n\n  /**\n   * @description Enables all controls within a FormGroup or FormArray.\n   * @summary Recursively enables all form controls within the provided FormGroup or FormArray.\n   * This is useful for making all controls interactive after they have been disabled.\n   *\n   * @param {FormArray | FormGroup} formGroup - The FormGroup or FormArray to enable all controls for\n   * @return {void}\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static enableAllGroupControls(formGroup: FormArray | FormGroup): void {\n    Object.keys(formGroup.controls).forEach(key => {\n      const control = formGroup.get(key);\n      if (control instanceof FormArray) {\n        control.controls.forEach(child => {\n          if (child instanceof FormGroup) {\n            child.enable({ emitEvent: false });\n            child.updateValueAndValidity({ emitEvent: true });\n          }\n        });\n      }\n    });\n  }\n\n  /**\n   * @description Adds a form control to a form group based on component properties.\n   * @summary Creates and configures a FormControl within the specified FormGroup using the provided\n   * component properties. Handles nested paths, multiple controls (FormArrays), and control registration.\n   * This method supports complex form structures with nested groups and arrays.\n   *\n   * @param {FormGroup} formGroup - The form group to add the control to\n   * @param {IComponentInput} componentProps - The component properties defining the control configuration\n   * @param {KeyValue} [parentProps={}] - Properties from the parent component for context\n   * @param {number} [index=0] - The index for multiple controls in FormArrays\n   * @return {void}\n   *\n   * @private\n   * @static\n   * @memberOf NgxFormService\n   */\n  private static addFormControl(formGroup: FormParent, componentProps: IComponentInput, parentProps: KeyValue = {}, index: number = 0): void {\n\n    const isMultiple = parentProps?.['multiple'] || parentProps?.['type'] === 'Array' || false;\n    const { name, childOf, } = componentProps;\n    if(isMultiple)\n      componentProps['pk'] = componentProps['pk'] || parentProps?.['pk'] || '';\n    const fullPath = childOf ? isMultiple ? `${childOf}.${index}.${name}` : `${childOf}.${name}` : name;\n    const [parentGroup, controlName] = this.resolveParentGroup(formGroup as FormGroup, fullPath, componentProps, parentProps);\n\n    if (!parentGroup.get(controlName)) {\n      const control = NgxFormService.fromProps(\n        componentProps,\n        componentProps.updateMode || 'change',\n      );\n      NgxFormService.register(control, componentProps);\n      if (parentGroup instanceof FormGroup) {\n        parentGroup.addControl(controlName, control);\n      }\n      if(parentGroup instanceof FormArray) {\n        const root = parentGroup.controls[(componentProps as KeyValue)?.['page'] - 1] as FormGroup;\n        if(root) {\n           root.addControl(controlName, control);\n        } else {\n          parentGroup.push({[controlName]: control});\n        }\n      }\n    }\n    const root = parentGroup instanceof FormArray ? parentGroup.controls[(componentProps as KeyValue)?.['page'] - 1] : parentGroup;\n    componentProps['formGroup'] = root as FormGroup;\n    componentProps['formControl'] = parentGroup.get(controlName) as FormControl;\n    componentProps['multiple'] = isMultiple\n  }\n\n  /**\n   * @description Retrieves a control from a registered form.\n   * @summary Finds and returns an AbstractControl from a registered form using the form id and optional path.\n   * This method provides centralized access to form controls across the application by leveraging\n   * the form registry system.\n   *\n   * @param {string} formId - The unique identifier of the form in the registry\n   * @param {string} [path] - The optional dot-separated path to a specific control within the form\n   * @return {AbstractControl} The requested AbstractControl (FormGroup, FormArray, or FormControl)\n   * @throws {Error} If the form is not found in the registry or the control is not found in the form\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant FR as Form Registry\n   *\n   *   C->>NFS: getControlFromForm(formId, path?)\n   *   NFS->>FR: Get form by formId\n   *   alt Form not found\n   *     FR-->>NFS: null\n   *     NFS-->>C: Throw Error\n   *   else Form found\n   *     FR-->>NFS: Return form\n   *     alt path provided\n   *       NFS->>NFS: form.get(path)\n   *       alt Control not found\n   *         NFS-->>C: Throw Error\n   *       else\n   *         NFS-->>C: Return control\n   *       end\n   *     else\n   *       NFS-->>C: Return form\n   *     end\n   *   end\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getControlFromForm(formId: string, path?: string): AbstractControl {\n    const form = this.formRegistry.get(formId);\n    if (!form)\n      throw new Error(`Form with id '${formId}' not found in the registry.`);\n\n    if (!path)\n      return form;\n\n    const control = form.get(path);\n    if (!control)\n      throw new Error(`Control with path '${path}' not found in form '${formId}'.`);\n    return control;\n  }\n\n\n  /**\n   * @description Creates a form from UI model metadata children.\n   * @summary Generates a FormGroup from an array of UIModelMetadata objects, extracting component\n   * properties and creating appropriate form controls. This method is specifically designed to work\n   * with the UI decorator system and provides automatic form generation from metadata.\n   *\n   * @param {string} id - Unique identifier for the form\n   * @param {boolean} [registry=false] - Whether to register the created form in the global registry\n   * @param {UIModelMetadata[]} [children] - Array of UI model metadata objects to create controls from\n   * @return {FormGroup} The created FormGroup with controls for each child metadata\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant AF as Angular Forms\n   *\n   *   C->>NFS: createFormFromChildren(id, registry, children)\n   *   NFS->>AF: new FormGroup({})\n   *   loop For each child metadata\n   *     NFS->>NFS: addFormControl(form, child.props)\n   *     NFS->>AF: Create and add FormControl\n   *   end\n   *   alt registry is true\n   *     NFS->>NFS: addRegistry(id, form)\n   *   end\n   *   NFS-->>C: Return FormGroup\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static createFormFromChildren(id: string, registry: boolean = false,  children?: UIModelMetadata[],): FormGroup {\n    const form = new FormGroup({});\n    if(children?.length)\n      children.forEach(child => {\n        this.addFormControl(form, child.props as IComponentInput);\n      });\n    if (registry)\n      this.addRegistry(id, form);\n    return form;\n  }\n\n  /**\n   * @description Creates a form from component configurations.\n   * @summary Generates a FormGroup based on an array of component configurations and optionally registers it.\n   * This method processes component input configurations to create appropriate form controls with\n   * validation and initial values.\n   *\n   * @param {string} id - The unique identifier for the form\n   * @param {IComponentConfig[]} components - An array of component configurations defining the form structure\n   * @param {boolean} [registry=false] - Whether to register the created form in the global registry\n   * @return {FormGroup} The created FormGroup with controls for each component configuration\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant AF as Angular Forms\n   *\n   *   C->>NFS: createFormFromComponents(id, components, registry)\n   *   NFS->>AF: new FormGroup({})\n   *   loop For each component config\n   *     NFS->>NFS: addFormControl(form, component.inputs)\n   *     NFS->>AF: Create and add FormControl\n   *   end\n   *   alt registry is true\n   *     NFS->>NFS: addRegistry(id, form)\n   *   end\n   *   NFS-->>C: Return FormGroup\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static createFormFromComponents(id: string, components: IComponentConfig[], registry: boolean = false): FormGroup {\n    const form = new FormGroup({});\n    components.forEach(component => {\n      this.addFormControl(form, component.inputs);\n    });\n\n    if (registry)\n      this.addRegistry(id, form);\n\n    return form;\n  }\n\n  /**\n   * @description Adds a control to a form based on component properties.\n   * @summary Creates and adds a form control to a form (existing or new) based on the provided component properties.\n   * Handles multi-page forms by managing FormArray structures and proper indexing. This method supports\n   * complex form scenarios including nested controls and page-based form organization.\n   *\n   * @param {string} id - The unique identifier of the form\n   * @param {FieldProperties} componentProperties - The properties of the component to create the control from\n   * @param {FieldProperties} [parentProps] - Optional parent properties for context and configuration\n   * @return {AbstractControl} The form or created control\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant F as Form\n   *\n   *   C->>NFS: addControlFromProps(id, componentProps, parentProps?)\n   *   NFS->>NFS: createForm(id, parentProps, true)\n   *   alt Multi-page form (parentProps.pages > 1)\n   *     NFS->>NFS: Calculate page index\n   *     NFS->>F: Get or create FormGroup at index\n   *     NFS->>NFS: Set form to page FormGroup\n   *   end\n   *   alt componentProperties has path\n   *     NFS->>NFS: addFormControl(form, componentProperties, parentProps)\n   *   end\n   *   NFS-->>C: Return form/control\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static addControlFromProps(id: string, componentProperties: FieldProperties, parentProps?: FieldProperties): AbstractControl {\n    let form = this.createForm(id, parentProps, true);\n    const formLength = (form as FormArray).length;\n    if(parentProps?.pages && parentProps?.pages > 1) {\n      let index = componentProperties.page || parentProps.page;\n      if(!(typeof index === 'number') || index === 0)\n        throw Error(`Property 'page' is required and greather than 0 on ${componentProperties.name}`);\n\n      if(index > formLength) {\n        if((form as KeyValue)?.['lastIndex'] && index === (form as KeyValue)['lastIndex']['page']) {\n          index = (form as KeyValue)['lastIndex']['index'];\n        } else {\n          (form as KeyValue)['lastIndex'] = {\n            page: index,\n            index: formLength + 1\n          };\n          index = formLength + 1;\n        }\n      }\n\n      let group = (form as FormArray).controls[(index as number) - 1];\n      if(!group) {\n        group = new FormGroup({});\n        (form as FormArray).insert(index as number, group);\n      }\n      form = group as FormGroup;\n    }\n    if(componentProperties.path)\n      this.addFormControl(form, componentProperties, parentProps);\n    return form;\n  }\n\n  /**\n   * @description Retrieves form data from a FormGroup.\n   * @summary Extracts and processes the data from a FormGroup, handling different input types and nested form groups.\n   * Performs type conversion for various HTML5 input types, validates nested controls, and manages\n   * multiple control scenarios. Automatically enables all group controls after data extraction.\n   *\n   * @param {FormGroup} formGroup - The FormGroup to extract data from\n   * @return {Record<string, unknown>} An object containing the processed form data with proper type conversions\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant FG as FormGroup\n   *   participant FC as FormControl\n   *\n   *   C->>NFS: getFormData(formGroup)\n   *   loop For each control in formGroup\n   *     alt Control is not FormControl\n   *       NFS->>NFS: Recursive getFormData(control)\n   *       alt parentProps.multiple and !isValid\n   *         NFS->>NFS: reset(control)\n   *       end\n   *     else Control is FormControl\n   *       NFS->>FC: Get control value\n   *       NFS->>NFS: Apply type conversion based on props.type\n   *       alt HTML5CheckTypes\n   *         NFS->>NFS: Keep boolean value\n   *       else NUMBER type\n   *         NFS->>NFS: parseToNumber(value)\n   *       else DATE/DATETIME types\n   *         NFS->>NFS: new Date(value)\n   *       else Other types\n   *         NFS->>NFS: escapeHtml(value)\n   *       end\n   *     end\n   *   end\n   *   NFS->>NFS: enableAllGroupControls(formGroup)\n   *   NFS-->>C: Return processed data object\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getFormData(formGroup: FormGroup): Record<string, unknown> {\n    const data: Record<string, unknown> = {};\n    for (const key in formGroup.controls) {\n      const control = formGroup.controls[key];\n      const parentProps = NgxFormService.getPropsFromControl(formGroup as FormGroup | FormArray);\n      if (!(control instanceof FormControl)) {\n        const value = NgxFormService.getFormData(control as FormGroup);\n        const isValid = control.valid;\n        if(parentProps.multiple) {\n            if(isValid) {\n               data[key] = value;\n            } else {\n              this.reset(control as FormControl);\n            }\n\n            continue;\n        }\n        data[key] = value;\n        continue;\n      }\n\n      const props = NgxFormService.getPropsFromControl(control as FormControl | FormArray);\n      let value = control.value;\n      if (!HTML5CheckTypes.includes(props['type'])) {\n        switch (props['type']) {\n          case HTML5InputTypes.NUMBER:\n            value = parseToNumber(value);\n            break;\n          case HTML5InputTypes.DATE:\n          case HTML5InputTypes.DATETIME_LOCAL:\n            value = new Date(value);\n            break;\n          default:\n            value = escapeHtml(value);\n        }\n      }\n      data[key] = value;\n    }\n    NgxFormService.enableAllGroupControls(formGroup as FormGroup);\n    return data;\n  }\n\n  /**\n   * @description Validates fields in a form control or form group.\n   * @summary Recursively validates all fields in a form control or form group, marking them as touched and dirty.\n   * Performs comprehensive validation including uniqueness checks for primary keys in FormArray scenarios.\n   * This method ensures all validation rules are applied and form state is properly updated.\n   *\n   * @param {AbstractControl} control - The control or form group to validate\n   * @param {string} [pk] - Optional primary key field name for uniqueness validation\n   * @param {string} [path] - The path to the control within the form for error reporting\n   * @return {boolean} True if all fields are valid, false otherwise\n   * @throws {Error} If no control is found at the specified path or if the control type is unknown\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant FC as FormControl\n   *   participant FG as FormGroup\n   *   participant FA as FormArray\n   *\n   *   C->>NFS: validateFields(control, pk?, path?)\n   *   alt Control is FormControl\n   *     NFS->>FC: markAsTouched()\n   *     NFS->>FC: markAsDirty()\n   *     NFS->>FC: updateValueAndValidity()\n   *     alt Is in FormArray group\n   *       NFS->>NFS: Check uniqueness in group\n   *       alt Not unique\n   *         NFS->>FC: setErrors({notUnique: true})\n   *       end\n   *     end\n   *     NFS-->>C: Return control.valid\n   *   else Control is FormGroup\n   *     loop For each child control\n   *       NFS->>NFS: Recursive validateFields(child)\n   *     end\n   *     NFS-->>C: Return allValid\n   *   else Control is FormArray\n   *     loop For each array control\n   *       NFS->>NFS: Recursive validateFields(child)\n   *     end\n   *     NFS-->>C: Return allValid\n   *   else Unknown control type\n   *     NFS-->>C: Throw Error\n   *   end\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static validateFields(control: AbstractControl, pk?: string,  path?: string): boolean {\n    control = path ? control.get(path) as AbstractControl : control;\n    if (!control)\n      throw new Error(`No control found at path: ${path || 'root'}.`);\n\n    const isAllowed = [FormArray, FormGroup, FormControl].some(type => control instanceof type);\n    if (!isAllowed)\n      throw new Error(`Unknown control type at: ${path || 'root'}`);\n\n    control.markAsTouched();\n    control.markAsDirty();\n    control.updateValueAndValidity({ emitEvent: true });\n\n    if (control instanceof FormGroup) {\n      Object.values(control.controls).forEach(childControl => {\n        this.validateFields(childControl);\n      });\n    }\n\n    if (control instanceof FormArray) {\n      const totalGroups = control.length;\n      const hasValid = control.controls.some(control => control.valid);\n      if(totalGroups > 1 && hasValid) {\n         for (let i = control.length - 1; i >= 0; i--) {\n          const childControl = control.at(i);\n          // disable no valid groups on array\n          if (!childControl.valid) {\n            (childControl.parent as FormGroup).setErrors(null);\n             (childControl.parent as FormGroup).updateValueAndValidity({ emitEvent: true });\n            childControl.disable();\n          } else {\n            this.validateFields(childControl);\n          }\n        }\n      } else {\n        Object.values(control.controls).forEach(childControl => {\n          this.validateFields(childControl);\n        });\n      }\n    }\n\n    // function getControlName(control: AbstractControl): string | null {\n    //   const group = control.parent as FormGroup;\n    //   if (!group)\n    //       return null;\n    //   return Object.keys(group.controls).find(name => control === group.get(name)) || null;\n    // }\n\n    return control.valid;\n  }\n\n  /**\n   * @description Generates validators from component properties.\n   * @summary Creates an array of ValidatorFn based on the supported validation keys in the component properties.\n   * @param {FieldProperties} props - The component properties.\n   * @return {ValidatorFn[]} An array of validator functions.\n   */\n  private static validatorsFromProps(props: FieldProperties): ValidatorFn[] {\n    const supportedValidationKeys = Validation.keys();\n    return Object.keys(props)\n      .filter((k: string) => supportedValidationKeys.includes(k))\n      .map((k: string) => {\n        return ValidatorFactory.spawn(props, k);\n      });\n  }\n\n  /**\n   * @description Creates a FormControl from component properties.\n   * @summary Generates a FormControl with validators and initial configuration based on the provided\n   * component properties. Handles different input types, sets initial values, and configures\n   * validation rules and update modes.\n   *\n   * @param {FieldProperties} props - The component properties defining the control configuration\n   * @param {FieldUpdateMode} [updateMode='change'] - The update mode for the control ('change', 'blur', 'submit')\n   * @return {FormControl} The created FormControl with proper configuration and validators\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant VF as ValidatorFactory\n   *   participant AF as Angular Forms\n   *\n   *   C->>NFS: fromProps(props, updateMode?)\n   *   NFS->>NFS: validatorsFromProps(props)\n   *   NFS->>VF: Create validators from props\n   *   VF-->>NFS: Return validator array\n   *   NFS->>NFS: Compose validators\n   *   alt props.value exists and not checkbox\n   *     alt props.type is DATE\n   *       NFS->>NFS: Validate date format\n   *     end\n   *     NFS->>NFS: Set initial value\n   *   end\n   *   NFS->>AF: new FormControl(config)\n   *   AF-->>NFS: Return FormControl\n   *   NFS-->>C: Return configured FormControl\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static fromProps(props: FieldProperties, updateMode: FieldUpdateMode = 'change'): FormControl {\n    const validators = this.validatorsFromProps(props);\n    const composed = validators.length ? Validators.compose(validators) : null;\n    return new FormControl(\n      {\n        value:\n          props.value && props.type !== HTML5InputTypes.CHECKBOX\n            ? props.type === HTML5InputTypes.DATE\n              ? !isValidDate(parseDate(props.format as string, props.value as string))\n                ? undefined : props.value :\n              (props.value as unknown) : undefined,\n        disabled: props.disabled,\n      },\n      {\n        validators: composed,\n        updateOn: updateMode,\n      },\n    );\n  }\n\n  /**\n   * @description Retrieves properties from a FormControl, FormArray, or FormGroup.\n   * @summary Gets the FieldProperties associated with a form control from the internal WeakMap.\n   * This method provides access to the original component properties that were used to create\n   * the control, enabling validation, rendering, and behavior configuration.\n   *\n   * @param {FormControl | FormArray | FormGroup} control - The form control to get properties for\n   * @return {FieldProperties} The properties associated with the control, or empty object if not found\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getPropsFromControl(control: FormControl | FormArray | FormGroup): FieldProperties {\n    return this.controls.get(control) || {} as FieldProperties;\n  }\n\n  /**\n   * @description Finds a parent element with a specific tag in the DOM tree.\n   * @summary Traverses up the DOM tree to find the nearest parent element with the specified tag name.\n   * This is useful for finding container elements or specific parent components in the DOM hierarchy.\n   * The search is case-insensitive for tag name matching.\n   *\n   * @param {HTMLElement} el - The starting element to traverse from\n   * @param {string} tag - The tag name to search for (case-insensitive)\n   * @return {HTMLElement} The found parent element with the specified tag\n   * @throws {Error} If no parent with the specified tag is found in the DOM tree\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant NFS as NgxFormService\n   *   participant DOM as DOM Tree\n   *\n   *   C->>NFS: getParentEl(element, tagName)\n   *   loop Traverse up DOM tree\n   *     NFS->>DOM: Get parentElement\n   *     DOM-->>NFS: Return parent or null\n   *     alt Parent exists and tag matches\n   *       NFS-->>C: Return parent element\n   *     else Parent is null\n   *       NFS-->>C: Throw Error\n   *     end\n   *   end\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static getParentEl(el: HTMLElement, tag: string): HTMLElement {\n    let parent: HTMLElement | null;\n    while ((parent = el.parentElement) !== null) {\n      if (parent.tagName.toLowerCase() === tag.toLowerCase()) {\n        return parent;\n      }\n      el = parent;\n    }\n    throw new Error(\n      `No parent with the tag ${tag} was found for provided element`,\n    );\n  }\n\n  /**\n   * @description Registers a control with its properties in the internal WeakMap.\n   * @summary Associates a form control with its component properties for later retrieval.\n   * This enables the service to maintain metadata about controls without creating memory leaks,\n   * as WeakMap automatically cleans up references when controls are garbage collected.\n   *\n   * @param {AbstractControl} control - The control to register (FormControl, FormGroup, or FormArray)\n   * @param {FieldProperties} props - The properties to associate with the control\n   * @return {void}\n   *\n   * @static\n   * @memberOf NgxFormService\n   */\n  static register(control: AbstractControl, props: FieldProperties): void {\n    this.controls.set(control, props);\n  }\n\n  /**\n   * @description Unregisters a control.\n   * @summary Removes a control and its associated properties from the internal WeakMap.\n   * @param {AbstractControl} control - The control to unregister.\n   * @return {boolean} True if the control was successfully unregistered, false otherwise.\n   */\n  static unregister(control: AbstractControl): boolean {\n    return this.controls.delete(control);\n  }\n\n  /**\n   * @description Resets a form group.\n   * @summary Recursively resets all controls in a form group, clearing values, errors, and marking them as pristine and untouched.\n   * @param {FormGroup} formGroup - The form group to reset.\n   */\n  static reset(formGroup: FormGroup | FormControl): void {\n    if(formGroup instanceof FormControl) {\n      const control = formGroup as FormControl;\n      const { type } = NgxFormService.getPropsFromControl(control);\n      if (!HTML5CheckTypes.includes(type))\n        control.setValue(\"\");\n      control.markAsPristine();\n      control.markAsUntouched();\n      control.setErrors(null);\n      control.updateValueAndValidity();\n    } else {\n      for (const key in formGroup.controls) {\n        const control = formGroup.controls[key];\n        NgxFormService.reset(control as FormControl);\n        continue;\n      }\n    }\n  }\n}\n"]}