@decaf-ts/for-angular 0.0.16 → 0.0.18

package/esm2022/engine/NgxRenderingEngine.mjs

@@ -2,38 +2,64 @@ import { RenderingEngine } from '@decaf-ts/ui-decorators';
 import { AngularEngineKeys } from './constants';
 import { InternalError } from '@decaf-ts/db-decorators';
 import { reflectComponentType, } from '@angular/core';
+import { NgxFormService } from './NgxFormService';
 /**
- * @description Angular implementation of the RenderingEngine
- * @summary This class extends the base RenderingEngine to provide Angular-specific rendering capabilities.
- * It handles the conversion of field definitions to Angular components and manages component registration.
+ * @description Angular implementation of the RenderingEngine with enhanced features
+ * @summary This class extends the base RenderingEngine to provide Angular-specific rendering capabilities
+ * with additional features compared to NgxRenderingEngine. It handles the conversion of field definitions
+ * to Angular components, manages component registration, and provides utilities for component creation
+ * and input handling. This implementation uses Angular's newer component APIs.
+ *
  * @template AngularFieldDefinition - Type for Angular-specific field definitions
  * @template AngularDynamicOutput - Type for Angular-specific component output
- * @param {Injector} injector - Angular injector for dependency injection
- * @param {ViewContainerRef} vcr - View container reference for component creation
- * @param {TemplateRef<any>} tpl - Template reference for content projection
+ *
  * @class NgxRenderingEngine
  * @example
  * ```typescript
- * const engine = new NgxRenderingEngine();
+ * const engine = NgxRenderingEngine.get();
  * engine.initialize();
  * const output = engine.render(myModel, {}, viewContainerRef, injector, templateRef);
  * ```
+ *
  * @mermaid
  * sequenceDiagram
  *   participant Client
  *   participant Engine as NgxRenderingEngine
  *   participant Components as RegisteredComponents
  *
- *   Client->>Engine: new NgxRenderingEngine()
+ *   Client->>Engine: get()
  *   Client->>Engine: initialize()
  *   Client->>Engine: render(model, props, vcr, injector, tpl)
  *   Engine->>Engine: toFieldDefinition(model, props)
  *   Engine->>Engine: fromFieldDefinition(fieldDef, vcr, injector, tpl)
  *   Engine->>Components: components(fieldDef.tag)
  *   Components-->>Engine: component constructor
- *   Engine->>Client: return AngularDynamicOutput
+ *   Engine->>Engine: createComponent(component, inputs, metadata, vcr, injector, template)
+ *   Engine-->>Client: return AngularDynamicOutput
  */
 export class NgxRenderingEngine extends RenderingEngine {
+    /**
+     * @description Current operation context for component visibility control
+     * @summary Static property that stores the current operation being performed,
+     * which is used to determine component visibility through the 'hidden' property.
+     * Components can specify operations where they should be hidden, and this property
+     * provides the context for those visibility checks. The value is typically extracted
+     * from the global properties during the rendering process.
+     *
+     * @private
+     * @static
+     * @type {string | undefined}
+     */
+    static { this._operation = undefined; }
+    /**
+     * @description Constructs a new NgxRenderingEngine instance
+     * @summary Initializes a new instance of the Angular rendering engine by calling the parent
+     * constructor with the 'angular' engine type identifier. This constructor sets up the base
+     * rendering engine functionality with Angular-specific configurations and prepares the
+     * instance for component registration and rendering operations.
+     *
+     * @constructor
+     */
     constructor() {
         super('angular');
     }
@@ -41,69 +67,142 @@ export class NgxRenderingEngine extends RenderingEngine {
      * @description Converts a field definition to an Angular component output
      * @summary This private method takes a field definition and creates the corresponding Angular component.
      * It handles component instantiation, input property mapping, and child component rendering.
+     * The method validates input properties against the component's metadata and processes
+     * child components recursively.
+     *
      * @param {FieldDefinition<AngularFieldDefinition>} fieldDef - The field definition to convert
      * @param {ViewContainerRef} vcr - The view container reference for component creation
      * @param {Injector} injector - The Angular injector for dependency injection
      * @param {TemplateRef<any>} tpl - The template reference for content projection
+     * @param {string} registryFormId - Form identifier for the component renderer
      * @return {AngularDynamicOutput} The Angular component output with component reference and inputs
+     *
      * @mermaid
      * sequenceDiagram
      *   participant Method as fromFieldDefinition
      *   participant Components as NgxRenderingEngine.components
      *   participant Angular as Angular Core
+     *   participant Process as processChild
      *
      *   Method->>Components: components(fieldDef.tag)
      *   Components-->>Method: component constructor
      *   Method->>Angular: reflectComponentType(component)
      *   Angular-->>Method: componentMetadata
-     *   Method->>Method: Check input properties
+     *   Method->>Method: Validate input properties
      *   Method->>Method: Create result object
-     *   Method->>Method: Process children if any
+     *   alt Has children
+     *     Method->>Process: Process children recursively
+     *     Process->>Method: Return processed children
+     *     Method->>Angular: Create embedded view
+     *     Method->>Method: Create component instance
+     *   end
      *   Method-->>Caller: return AngularDynamicOutput
      */
-    fromFieldDefinition(fieldDef, vcr, injector, tpl) {
-        const component = NgxRenderingEngine.components(fieldDef.tag)
-            .constructor;
+    fromFieldDefinition(fieldDef, vcr, injector, tpl, registryFormId = Date.now().toString(36).toUpperCase()) {
+        const cmp = fieldDef?.['component'] || NgxRenderingEngine.components(fieldDef.tag);
+        const component = cmp.constructor;
         const componentMetadata = reflectComponentType(component);
         if (!componentMetadata) {
             throw new InternalError(`Metadata for component ${fieldDef.tag} not found.`);
         }
-        const inputs = fieldDef.props;
-        const possibleInputs = componentMetadata.inputs;
-        const inputKeys = Object.keys(inputs);
-        for (const input of possibleInputs) {
-            const index = inputKeys.indexOf(input.propName);
-            if (index !== -1) {
-                inputKeys.splice(index, 1);
-            }
-            if (!inputKeys.length)
-                break;
-        }
-        if (inputKeys.length)
-            console.warn(`Unmapped input properties for component ${fieldDef.tag}: ${inputKeys.join(', ')}`);
+        const { inputs: possibleInputs } = componentMetadata;
+        const inputs = { ...fieldDef.props };
+        const unmappedKeys = Object.keys(inputs).filter(input => {
+            const isMapped = possibleInputs.find(({ propName }) => propName === input);
+            if (!isMapped)
+                delete inputs[input];
+            return !isMapped;
+        });
+        if (unmappedKeys.length > 0)
+            console.warn(`Unmapped input properties for component ${fieldDef.tag}: ${unmappedKeys.join(', ')}`);
+        const operation = NgxRenderingEngine._operation;
+        const hiddenOn = inputs?.hidden || [];
+        if (hiddenOn.includes(operation))
+            return { inputs, injector };
+        // const hiddenOn = inputs?.hidden || [];
         const result = {
-            component: component,
-            inputs: inputs || {},
-            injector: injector,
+            component,
+            inputs,
+            injector,
         };
-        if (fieldDef.rendererId) {
-            result.inputs['rendererId'] =
-                fieldDef.rendererId;
-        }
-        if (fieldDef.children && fieldDef.children.length) {
+        if (fieldDef.rendererId)
+            result.inputs['rendererId'] = fieldDef.rendererId;
+        // process children
+        if (fieldDef.children?.length) {
             result.children = fieldDef.children.map((child) => {
-                return this.fromFieldDefinition(child, vcr, injector, tpl);
+                if (child?.children?.length) {
+                    child.children = child.children.filter(c => {
+                        const hiddenOn = c?.props?.hidden || [];
+                        if (!hiddenOn.includes(operation))
+                            return c;
+                    });
+                }
+                // create a child form and add its controls as properties of child.props
+                NgxFormService.addControlFromProps(registryFormId, child.props, inputs);
+                return this.fromFieldDefinition(child, vcr, injector, tpl, registryFormId);
             });
-            const template = vcr.createEmbeddedView(tpl, injector).rootNodes;
-            result.content = [template];
         }
+        // generating DOM
+        vcr.clear();
+        const template = vcr.createEmbeddedView(tpl, injector).rootNodes;
+        const componentInstance = NgxRenderingEngine.createComponent(component, { ...inputs, model: this._model }, componentMetadata, vcr, injector, template);
+        result.instance = NgxRenderingEngine._instance = componentInstance.instance;
         return result;
     }
+    /**
+     * @description Creates an Angular component instance
+     * @summary This static utility method creates an Angular component instance with the specified
+     * inputs and template. It uses Angular's component creation API to instantiate the component
+     * and then sets the input properties using the provided metadata.
+     *
+     * @param {Type<unknown>} component - The component type to create
+     * @param {KeyValue} [inputs={}] - The input properties to set on the component
+     * @param {ComponentMirror<unknown>} metadata - The component metadata for input validation
+     * @param {ViewContainerRef} vcr - The view container reference for component creation
+     * @param {Injector} injector - The Angular injector for dependency injection
+     * @param {Node[]} [template=[]] - The template nodes to project into the component
+     * @return {ComponentRef<unknown>} The created component reference
+     */
+    static createComponent(component, inputs = {}, metadata, vcr, injector, template = []) {
+        const componentInstance = vcr.createComponent(component, {
+            environmentInjector: injector,
+            projectableNodes: [template],
+        });
+        this.setInputs(componentInstance, inputs, metadata);
+        return componentInstance;
+    }
+    /**
+     * @description Extracts decorator metadata from a model
+     * @summary This method provides access to the field definition generated from a model's
+     * decorators. It's a convenience wrapper around the toFieldDefinition method that
+     * converts a model to a field definition based on its decorators and the provided
+     * global properties.
+     *
+     * @param {Model} model - The model to extract decorators from
+     * @param {Record<string, unknown>} globalProps - Global properties to include in the field definition
+     * @return {FieldDefinition<AngularFieldDefinition>} The field definition generated from the model
+     */
+    getDecorators(model, globalProps) {
+        return this.toFieldDefinition(model, globalProps);
+    }
+    /**
+     * @description Destroys the current engine instance
+     * @summary This static method clears the current instance reference, effectively
+     * destroying the singleton instance of the rendering engine. This can be used
+     * to reset the engine state or to prepare for a new instance creation.
+     *
+     * @return {Promise<void>} A promise that resolves when the instance is destroyed
+     */
+    static async destroy() {
+        NgxRenderingEngine._instance = undefined;
+    }
     /**
      * @description Renders a model into an Angular component output
      * @summary This method takes a model and converts it to an Angular component output.
-     * It first converts the model to a field definition using the base RenderingEngine's
-     * toFieldDefinition method, then converts that field definition to an Angular component output.
+     * It first stores a reference to the model, then converts it to a field definition
+     * using the base RenderingEngine's toFieldDefinition method, and finally converts
+     * that field definition to an Angular component output using fromFieldDefinition.
+     *
      * @template M - Type extending Model
      * @param {M} model - The model to render
      * @param {Record<string, unknown>} globalProps - Global properties to pass to the component
@@ -111,6 +210,7 @@ export class NgxRenderingEngine extends RenderingEngine {
      * @param {Injector} injector - The Angular injector for dependency injection
      * @param {TemplateRef<any>} tpl - The template reference for content projection
      * @return {AngularDynamicOutput} The Angular component output with component reference and inputs
+     *
      * @mermaid
      * sequenceDiagram
      *   participant Client as Client Code
@@ -119,6 +219,7 @@ export class NgxRenderingEngine extends RenderingEngine {
      *   participant FromField as fromFieldDefinition
      *
      *   Client->>Render: render(model, globalProps, vcr, injector, tpl)
+     *   Render->>Render: Store model reference
      *   Render->>ToField: toFieldDefinition(model, globalProps)
      *   ToField-->>Render: fieldDef
      *   Render->>FromField: fromFieldDefinition(fieldDef, vcr, injector, tpl)
@@ -128,8 +229,15 @@ export class NgxRenderingEngine extends RenderingEngine {
     render(model, globalProps, vcr, injector, tpl) {
         let result;
         try {
+            this._model = model;
+            const formId = Date.now().toString(36).toUpperCase();
             const fieldDef = this.toFieldDefinition(model, globalProps);
-            result = this.fromFieldDefinition(fieldDef, vcr, injector, tpl);
+            const props = fieldDef.props;
+            if (!NgxRenderingEngine._operation)
+                NgxRenderingEngine._operation = props?.['operation'] || undefined;
+            result = this.fromFieldDefinition(fieldDef, vcr, injector, tpl, formId);
+            result.instance['formGroup'] = NgxFormService.getControlFromForm(formId);
+            NgxFormService.removeRegistry(formId);
         }
         catch (e) {
             throw new InternalError(`Failed to render Model ${model.constructor.name}: ${e}`);
@@ -139,18 +247,24 @@ export class NgxRenderingEngine extends RenderingEngine {
     /**
      * @description Initializes the rendering engine
      * @summary This method initializes the rendering engine. It checks if the engine is already initialized
-     * and sets the initialized flag to true. This method is called before the engine is used.
+     * and sets the initialized flag to true. This method is called before the engine is used
+     * to ensure it's properly set up for rendering operations.
+     *
      * @return {Promise<void>} A promise that resolves when initialization is complete
      */
     async initialize() {
         if (this.initialized)
             return;
+        // ValidatableByType[]
         this.initialized = true;
     }
     /**
      * @description Registers a component with the rendering engine
      * @summary This static method registers a component constructor with the rendering engine
-     * under a specific name. It throws an error if a component is already registered under the same name.
+     * under a specific name. It initializes the components registry if needed and throws
+     * an error if a component is already registered under the same name to prevent
+     * accidental overrides.
+     *
      * @param {string} name - The name to register the component under
      * @param {Constructor<unknown>} constructor - The component constructor
      * @return {void}
@@ -167,7 +281,10 @@ export class NgxRenderingEngine extends RenderingEngine {
     /**
      * @description Retrieves registered components from the rendering engine
      * @summary This static method retrieves either all registered components or a specific component
-     * by its selector. It throws an error if the requested component is not registered.
+     * by its selector. When called without a selector, it returns an array of all registered
+     * components. When called with a selector, it returns the specific component if found,
+     * or throws an error if the component is not registered.
+     *
      * @param {string} [selector] - Optional selector to retrieve a specific component
      * @return {Object|Array} Either a specific component or an array of all components
      */
@@ -181,12 +298,67 @@ export class NgxRenderingEngine extends RenderingEngine {
     /**
      * @description Generates a key for reflection metadata
      * @summary This static method generates a key for reflection metadata by prefixing the input key
-     * with the Angular engine's reflection prefix. This is used for storing and retrieving metadata.
+     * with the Angular engine's reflection prefix. This is used for storing and retrieving
+     * metadata in a namespaced way to avoid conflicts with other metadata.
+     *
      * @param {string} key - The base key to prefix
      * @return {string} The prefixed key for reflection metadata
      */
     static key(key) {
         return `${AngularEngineKeys.REFLECT}${key}`;
     }
+    /**
+     * @description Sets input properties on a component instance
+     * @summary This static utility method sets input properties on a component instance
+     * based on the provided inputs object and component metadata. It handles both simple
+     * values and nested objects, recursively processing object properties. The method
+     * validates each input against the component's metadata to ensure only valid inputs
+     * are set.
+     *
+     * @param {ComponentRef<unknown>} component - The component reference to set inputs on
+     * @param {KeyValue} inputs - The input properties to set
+     * @param {ComponentMirror<unknown>} metadata - The component metadata for input validation
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant SetInputs as setInputs
+     *   participant Parse as parseInputValue
+     *   participant Component as ComponentRef
+     *
+     *   Caller->>SetInputs: setInputs(component, inputs, metadata)
+     *   SetInputs->>SetInputs: Iterate through inputs
+     *   loop For each input
+     *     SetInputs->>SetInputs: Check if input exists in metadata
+     *     alt Input is 'props'
+     *       SetInputs->>Parse: parseInputValue(component, value)
+     *       Parse->>Parse: Recursively process nested objects
+     *       Parse->>Component: setInput(key, value)
+     *     else Input is valid
+     *       SetInputs->>Component: setInput(key, value)
+     *     end
+     *   end
+     */
+    static setInputs(component, inputs, metadata) {
+        function parseInputValue(component, input) {
+            Object.keys(input).forEach(key => {
+                const value = input[key];
+                if (typeof value === 'object' && !!value)
+                    return parseInputValue(component, value);
+                component.setInput(key, value);
+            });
+        }
+        Object.entries(inputs).forEach(([key, value]) => {
+            const prop = metadata.inputs.find((item) => item.propName === key);
+            if (prop) {
+                if (key === 'props')
+                    parseInputValue(component, value);
+                // if(key === 'locale' && !value)
+                //   value = getLocaleFromClassName(this._componentName);
+                component.setInput(key, value);
+            }
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxRenderingEngine.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxRenderingEngine.ts"],"names":[],"mappings":"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","sourcesContent":["import { FieldDefinition, RenderingEngine } from '@decaf-ts/ui-decorators';\nimport { AngularDynamicOutput, AngularFieldDefinition } from './types';\nimport { AngularEngineKeys } from './constants';\nimport { Constructor, Model } from '@decaf-ts/decorator-validation';\nimport { InternalError } from '@decaf-ts/db-decorators';\nimport {\n  Injector,\n  reflectComponentType,\n  TemplateRef,\n  Type,\n  ViewContainerRef,\n} from '@angular/core';\n\n/**\n * @description Angular implementation of the RenderingEngine\n * @summary This class extends the base RenderingEngine to provide Angular-specific rendering capabilities.\n * It handles the conversion of field definitions to Angular components and manages component registration.\n * @template AngularFieldDefinition - Type for Angular-specific field definitions\n * @template AngularDynamicOutput - Type for Angular-specific component output\n * @param {Injector} injector - Angular injector for dependency injection\n * @param {ViewContainerRef} vcr - View container reference for component creation\n * @param {TemplateRef<any>} tpl - Template reference for content projection\n * @class NgxRenderingEngine\n * @example\n * ```typescript\n * const engine = new NgxRenderingEngine();\n * engine.initialize();\n * const output = engine.render(myModel, {}, viewContainerRef, injector, templateRef);\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Engine as NgxRenderingEngine\n *   participant Components as RegisteredComponents\n *\n *   Client->>Engine: new NgxRenderingEngine()\n *   Client->>Engine: initialize()\n *   Client->>Engine: render(model, props, vcr, injector, tpl)\n *   Engine->>Engine: toFieldDefinition(model, props)\n *   Engine->>Engine: fromFieldDefinition(fieldDef, vcr, injector, tpl)\n *   Engine->>Components: components(fieldDef.tag)\n *   Components-->>Engine: component constructor\n *   Engine->>Client: return AngularDynamicOutput\n */\nexport class NgxRenderingEngine extends RenderingEngine<\n  AngularFieldDefinition,\n  AngularDynamicOutput\n> {\n  private static _components: Record<\n    string,\n    { constructor: Constructor<unknown> }\n  >;\n\n  constructor() {\n    super('angular');\n  }\n\n  /**\n   * @description Converts a field definition to an Angular component output\n   * @summary This private method takes a field definition and creates the corresponding Angular component.\n   * It handles component instantiation, input property mapping, and child component rendering.\n   * @param {FieldDefinition<AngularFieldDefinition>} fieldDef - The field definition to convert\n   * @param {ViewContainerRef} vcr - The view container reference for component creation\n   * @param {Injector} injector - The Angular injector for dependency injection\n   * @param {TemplateRef<any>} tpl - The template reference for content projection\n   * @return {AngularDynamicOutput} The Angular component output with component reference and inputs\n   * @mermaid\n   * sequenceDiagram\n   *   participant Method as fromFieldDefinition\n   *   participant Components as NgxRenderingEngine.components\n   *   participant Angular as Angular Core\n   *\n   *   Method->>Components: components(fieldDef.tag)\n   *   Components-->>Method: component constructor\n   *   Method->>Angular: reflectComponentType(component)\n   *   Angular-->>Method: componentMetadata\n   *   Method->>Method: Check input properties\n   *   Method->>Method: Create result object\n   *   Method->>Method: Process children if any\n   *   Method-->>Caller: return AngularDynamicOutput\n   */\n  private fromFieldDefinition(\n    fieldDef: FieldDefinition<AngularFieldDefinition>,\n    vcr: ViewContainerRef,\n    injector: Injector,\n    tpl: TemplateRef<unknown>,\n  ): AngularDynamicOutput {\n    const component = NgxRenderingEngine.components(fieldDef.tag)\n      .constructor as unknown as Type<unknown>;\n\n    const componentMetadata = reflectComponentType(component);\n    if (!componentMetadata) {\n      throw new InternalError(\n        `Metadata for component ${fieldDef.tag} not found.`,\n      );\n    }\n    const inputs = fieldDef.props;\n\n    const possibleInputs = componentMetadata.inputs;\n    const inputKeys = Object.keys(inputs);\n    for (const input of possibleInputs) {\n      const index = inputKeys.indexOf(input.propName);\n      if (index !== -1) {\n        inputKeys.splice(index, 1);\n      }\n      if (!inputKeys.length) break;\n    }\n\n    if (inputKeys.length)\n      console.warn(\n        `Unmapped input properties for component ${fieldDef.tag}: ${inputKeys.join(', ')}`,\n      );\n\n    const result: AngularDynamicOutput = {\n      component: component,\n      inputs: inputs || {},\n      injector: injector,\n    };\n\n    if (fieldDef.rendererId) {\n      (result.inputs as Record<string, unknown>)['rendererId'] =\n        fieldDef.rendererId;\n    }\n\n    if (fieldDef.children && fieldDef.children.length) {\n      result.children = fieldDef.children.map((child) => {\n        return this.fromFieldDefinition(child, vcr, injector, tpl);\n      });\n\n      const template = vcr.createEmbeddedView(tpl, injector).rootNodes;\n      result.content = [template];\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Renders a model into an Angular component output\n   * @summary This method takes a model and converts it to an Angular component output.\n   * It first converts the model to a field definition using the base RenderingEngine's\n   * toFieldDefinition method, then converts that field definition to an Angular component output.\n   * @template M - Type extending Model\n   * @param {M} model - The model to render\n   * @param {Record<string, unknown>} globalProps - Global properties to pass to the component\n   * @param {ViewContainerRef} vcr - The view container reference for component creation\n   * @param {Injector} injector - The Angular injector for dependency injection\n   * @param {TemplateRef<any>} tpl - The template reference for content projection\n   * @return {AngularDynamicOutput} The Angular component output with component reference and inputs\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client as Client Code\n   *   participant Render as render method\n   *   participant ToField as toFieldDefinition\n   *   participant FromField as fromFieldDefinition\n   *\n   *   Client->>Render: render(model, globalProps, vcr, injector, tpl)\n   *   Render->>ToField: toFieldDefinition(model, globalProps)\n   *   ToField-->>Render: fieldDef\n   *   Render->>FromField: fromFieldDefinition(fieldDef, vcr, injector, tpl)\n   *   FromField-->>Render: AngularDynamicOutput\n   *   Render-->>Client: return AngularDynamicOutput\n   */\n  override render<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown>,\n    vcr: ViewContainerRef,\n    injector: Injector,\n    tpl: TemplateRef<unknown>,\n  ): AngularDynamicOutput {\n    let result: AngularDynamicOutput;\n    try {\n      const fieldDef = this.toFieldDefinition(model, globalProps);\n      result = this.fromFieldDefinition(fieldDef, vcr, injector, tpl);\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Failed to render Model ${model.constructor.name}: ${e}`,\n      );\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Initializes the rendering engine\n   * @summary This method initializes the rendering engine. It checks if the engine is already initialized\n   * and sets the initialized flag to true. This method is called before the engine is used.\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  override async initialize(): Promise<void> {\n    if (this.initialized) return;\n    this.initialized = true;\n  }\n\n  /**\n   * @description Registers a component with the rendering engine\n   * @summary This static method registers a component constructor with the rendering engine\n   * under a specific name. It throws an error if a component is already registered under the same name.\n   * @param {string} name - The name to register the component under\n   * @param {Constructor<unknown>} constructor - The component constructor\n   * @return {void}\n   */\n  static registerComponent(name: string, constructor: Constructor<unknown>) {\n    if (!this._components) this._components = {};\n    if (name in this._components)\n      throw new InternalError(`Component already registered under ${name}`);\n    this._components[name] = {\n      constructor: constructor,\n    };\n  }\n\n  /**\n   * @description Retrieves registered components from the rendering engine\n   * @summary This static method retrieves either all registered components or a specific component\n   * by its selector. It throws an error if the requested component is not registered.\n   * @param {string} [selector] - Optional selector to retrieve a specific component\n   * @return {Object|Array} Either a specific component or an array of all components\n   */\n  static components(selector?: string) {\n    if (!selector) return Object.values(this._components);\n    if (!(selector in this._components))\n      throw new InternalError(`No Component registered under ${selector}`);\n    return this._components[selector];\n  }\n\n  /**\n   * @description Generates a key for reflection metadata\n   * @summary This static method generates a key for reflection metadata by prefixing the input key\n   * with the Angular engine's reflection prefix. This is used for storing and retrieving metadata.\n   * @param {string} key - The base key to prefix\n   * @return {string} The prefixed key for reflection metadata\n   */\n  static override key(key: string) {\n    return `${AngularEngineKeys.REFLECT}${key}`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxRenderingEngine.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxRenderingEngine.ts"],"names":[],"mappings":"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","sourcesContent":["import { FieldDefinition, RenderingEngine } from '@decaf-ts/ui-decorators';\nimport { AngularFieldDefinition, KeyValue } from './types';\nimport { AngularDynamicOutput } from './interfaces';\nimport { AngularEngineKeys } from './constants';\nimport { Constructor, Model} from '@decaf-ts/decorator-validation';\nimport { InternalError } from '@decaf-ts/db-decorators';\nimport {\n  ComponentMirror,\n  ComponentRef,\n  EnvironmentInjector,\n  Injector,\n  reflectComponentType,\n  TemplateRef,\n  Type,\n  ViewContainerRef,\n} from '@angular/core';\nimport { NgxFormService } from './NgxFormService';\n\n/**\n * @description Angular implementation of the RenderingEngine with enhanced features\n * @summary This class extends the base RenderingEngine to provide Angular-specific rendering capabilities\n * with additional features compared to NgxRenderingEngine. It handles the conversion of field definitions\n * to Angular components, manages component registration, and provides utilities for component creation\n * and input handling. This implementation uses Angular's newer component APIs.\n *\n * @template AngularFieldDefinition - Type for Angular-specific field definitions\n * @template AngularDynamicOutput - Type for Angular-specific component output\n *\n * @class NgxRenderingEngine\n * @example\n * ```typescript\n * const engine = NgxRenderingEngine.get();\n * engine.initialize();\n * const output = engine.render(myModel, {}, viewContainerRef, injector, templateRef);\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Engine as NgxRenderingEngine\n *   participant Components as RegisteredComponents\n *\n *   Client->>Engine: get()\n *   Client->>Engine: initialize()\n *   Client->>Engine: render(model, props, vcr, injector, tpl)\n *   Engine->>Engine: toFieldDefinition(model, props)\n *   Engine->>Engine: fromFieldDefinition(fieldDef, vcr, injector, tpl)\n *   Engine->>Components: components(fieldDef.tag)\n *   Components-->>Engine: component constructor\n *   Engine->>Engine: createComponent(component, inputs, metadata, vcr, injector, template)\n *   Engine-->>Client: return AngularDynamicOutput\n */\nexport class NgxRenderingEngine extends RenderingEngine<AngularFieldDefinition, AngularDynamicOutput> {\n\n  /**\n   * @description Registry of components available for rendering\n   * @summary Static registry that stores all registered components indexed by their selector name.\n   * Each component entry contains a constructor reference that can be used to instantiate\n   * the component during the rendering process. This registry is shared across all instances\n   * of the rendering engine and is populated through the registerComponent method.\n   *\n   * @private\n   * @static\n   * @type {Record<string, { constructor: Constructor<unknown> }>}\n   */\n  private static _components: Record<string, { constructor: Constructor<unknown> }>;\n\n  /**\n   * @description Currently active model being rendered\n   * @summary Stores a reference to the model instance that is currently being processed\n   * by the rendering engine. This property is set during the render method execution\n   * and is used throughout the rendering lifecycle to access model data and metadata.\n   * The definite assignment assertion (!) is used because this property is always\n   * initialized before use within the render method.\n   *\n   * @private\n   * @type {Model}\n   */\n  private _model!: Model;\n\n  /**\n   * @description Current operation context for component visibility control\n   * @summary Static property that stores the current operation being performed,\n   * which is used to determine component visibility through the 'hidden' property.\n   * Components can specify operations where they should be hidden, and this property\n   * provides the context for those visibility checks. The value is typically extracted\n   * from the global properties during the rendering process.\n   *\n   * @private\n   * @static\n   * @type {string | undefined}\n   */\n  private static _operation: string | undefined = undefined;\n\n  /**\n   * @description Reference to the currently active component instance\n   * @summary Static property that maintains a reference to the most recently created\n   * component instance. This is used internally for component lifecycle management\n   * and can be cleared through the destroy method. The reference allows access to\n   * the active component instance for operations that need to interact with the\n   * currently rendered component.\n   *\n   * @private\n   * @static\n   * @type {Type<unknown> | undefined}\n   */\n  private static _instance: Type<unknown> | undefined;\n\n  /**\n   * @description Constructs a new NgxRenderingEngine instance\n   * @summary Initializes a new instance of the Angular rendering engine by calling the parent\n   * constructor with the 'angular' engine type identifier. This constructor sets up the base\n   * rendering engine functionality with Angular-specific configurations and prepares the\n   * instance for component registration and rendering operations.\n   *\n   * @constructor\n   */\n  constructor() {\n    super('angular');\n  }\n\n  /**\n   * @description Converts a field definition to an Angular component output\n   * @summary This private method takes a field definition and creates the corresponding Angular component.\n   * It handles component instantiation, input property mapping, and child component rendering.\n   * The method validates input properties against the component's metadata and processes\n   * child components recursively.\n   *\n   * @param {FieldDefinition<AngularFieldDefinition>} fieldDef - The field definition to convert\n   * @param {ViewContainerRef} vcr - The view container reference for component creation\n   * @param {Injector} injector - The Angular injector for dependency injection\n   * @param {TemplateRef<any>} tpl - The template reference for content projection\n   * @param {string} registryFormId - Form identifier for the component renderer\n   * @return {AngularDynamicOutput} The Angular component output with component reference and inputs\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Method as fromFieldDefinition\n   *   participant Components as NgxRenderingEngine.components\n   *   participant Angular as Angular Core\n   *   participant Process as processChild\n   *\n   *   Method->>Components: components(fieldDef.tag)\n   *   Components-->>Method: component constructor\n   *   Method->>Angular: reflectComponentType(component)\n   *   Angular-->>Method: componentMetadata\n   *   Method->>Method: Validate input properties\n   *   Method->>Method: Create result object\n   *   alt Has children\n   *     Method->>Process: Process children recursively\n   *     Process->>Method: Return processed children\n   *     Method->>Angular: Create embedded view\n   *     Method->>Method: Create component instance\n   *   end\n   *   Method-->>Caller: return AngularDynamicOutput\n   */\n  private fromFieldDefinition(\n    fieldDef: FieldDefinition<AngularFieldDefinition>,\n    vcr: ViewContainerRef,\n    injector: Injector,\n    tpl: TemplateRef<unknown>,\n    registryFormId: string = Date.now().toString(36).toUpperCase(),\n  ): AngularDynamicOutput {\n    const cmp = (fieldDef as KeyValue)?.['component'] || NgxRenderingEngine.components(fieldDef.tag);\n    const component = cmp.constructor as unknown as Type<unknown>;\n\n    const componentMetadata = reflectComponentType(component);\n    if (!componentMetadata) {\n      throw new InternalError(`Metadata for component ${fieldDef.tag} not found.`);\n    }\n\n    const { inputs: possibleInputs } = componentMetadata;\n    const inputs = { ...fieldDef.props };\n\n    const unmappedKeys = Object.keys(inputs).filter(input => {\n      const isMapped = possibleInputs.find(({ propName }) => propName === input);\n      if (!isMapped) delete inputs[input];\n      return !isMapped;\n    });\n\n    if (unmappedKeys.length > 0)\n      console.warn(`Unmapped input properties for component ${fieldDef.tag}: ${unmappedKeys.join(', ')}`);\n\n    const operation = NgxRenderingEngine._operation;\n\n    const hiddenOn = inputs?.hidden || [];\n    if((hiddenOn as string[]).includes(operation as string))\n      return {inputs, injector};\n    // const hiddenOn = inputs?.hidden || [];\n    const result: AngularDynamicOutput = {\n      component,\n      inputs,\n      injector,\n    };\n\n    if (fieldDef.rendererId)\n      (result.inputs as Record<string, unknown>)['rendererId'] = fieldDef.rendererId;\n\n    // process children\n    if (fieldDef.children?.length) {\n      result.children = fieldDef.children.map((child) => {\n        if(child?.children?.length) {\n          child.children = child.children.filter(c => {\n            const hiddenOn = c?.props?.hidden || [];\n            if(!(hiddenOn as string[]).includes(operation as string))\n              return c\n          })\n        }\n        // create a child form and add its controls as properties of child.props\n        NgxFormService.addControlFromProps(registryFormId, child.props, inputs);\n        return this.fromFieldDefinition(child, vcr, injector, tpl, registryFormId);\n      });\n    }\n\n    // generating DOM\n    vcr.clear();\n    const template = vcr.createEmbeddedView(tpl, injector).rootNodes;\n    const componentInstance = NgxRenderingEngine.createComponent(\n      component,\n      { ...inputs, model: this._model },\n      componentMetadata,\n      vcr,\n      injector,\n      template,\n    );\n\n    result.instance = NgxRenderingEngine._instance = componentInstance.instance as Type<unknown>;\n\n    return result;\n  }\n\n\n  /**\n   * @description Creates an Angular component instance\n   * @summary This static utility method creates an Angular component instance with the specified\n   * inputs and template. It uses Angular's component creation API to instantiate the component\n   * and then sets the input properties using the provided metadata.\n   *\n   * @param {Type<unknown>} component - The component type to create\n   * @param {KeyValue} [inputs={}] - The input properties to set on the component\n   * @param {ComponentMirror<unknown>} metadata - The component metadata for input validation\n   * @param {ViewContainerRef} vcr - The view container reference for component creation\n   * @param {Injector} injector - The Angular injector for dependency injection\n   * @param {Node[]} [template=[]] - The template nodes to project into the component\n   * @return {ComponentRef<unknown>} The created component reference\n   */\n  static createComponent(component: Type<unknown>, inputs: KeyValue = {}, metadata: ComponentMirror<unknown>, vcr: ViewContainerRef, injector: Injector, template: Node[] = []): ComponentRef<unknown> {\n    const componentInstance = vcr.createComponent(component as Type<unknown>, {\n      environmentInjector: injector as EnvironmentInjector,\n      projectableNodes: [template],\n    });\n    this.setInputs(componentInstance, inputs, metadata);\n    return componentInstance;\n  }\n\n  /**\n   * @description Extracts decorator metadata from a model\n   * @summary This method provides access to the field definition generated from a model's\n   * decorators. It's a convenience wrapper around the toFieldDefinition method that\n   * converts a model to a field definition based on its decorators and the provided\n   * global properties.\n   *\n   * @param {Model} model - The model to extract decorators from\n   * @param {Record<string, unknown>} globalProps - Global properties to include in the field definition\n   * @return {FieldDefinition<AngularFieldDefinition>} The field definition generated from the model\n   */\n  getDecorators(model: Model, globalProps: Record<string, unknown>): FieldDefinition<AngularFieldDefinition> {\n    return this.toFieldDefinition(model, globalProps);\n  }\n\n  /**\n   * @description Destroys the current engine instance\n   * @summary This static method clears the current instance reference, effectively\n   * destroying the singleton instance of the rendering engine. This can be used\n   * to reset the engine state or to prepare for a new instance creation.\n   *\n   * @return {Promise<void>} A promise that resolves when the instance is destroyed\n   */\n  static async destroy(): Promise<void> {\n    NgxRenderingEngine._instance = undefined;\n  }\n\n\n  /**\n   * @description Renders a model into an Angular component output\n   * @summary This method takes a model and converts it to an Angular component output.\n   * It first stores a reference to the model, then converts it to a field definition\n   * using the base RenderingEngine's toFieldDefinition method, and finally converts\n   * that field definition to an Angular component output using fromFieldDefinition.\n   *\n   * @template M - Type extending Model\n   * @param {M} model - The model to render\n   * @param {Record<string, unknown>} globalProps - Global properties to pass to the component\n   * @param {ViewContainerRef} vcr - The view container reference for component creation\n   * @param {Injector} injector - The Angular injector for dependency injection\n   * @param {TemplateRef<any>} tpl - The template reference for content projection\n   * @return {AngularDynamicOutput} The Angular component output with component reference and inputs\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client as Client Code\n   *   participant Render as render method\n   *   participant ToField as toFieldDefinition\n   *   participant FromField as fromFieldDefinition\n   *\n   *   Client->>Render: render(model, globalProps, vcr, injector, tpl)\n   *   Render->>Render: Store model reference\n   *   Render->>ToField: toFieldDefinition(model, globalProps)\n   *   ToField-->>Render: fieldDef\n   *   Render->>FromField: fromFieldDefinition(fieldDef, vcr, injector, tpl)\n   *   FromField-->>Render: AngularDynamicOutput\n   *   Render-->>Client: return AngularDynamicOutput\n   */\n  override render<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown>,\n    vcr: ViewContainerRef,\n    injector: Injector,\n    tpl: TemplateRef<unknown>,\n  ): AngularDynamicOutput {\n    let result: AngularDynamicOutput;\n    try {\n      this._model = model;\n      const formId = Date.now().toString(36).toUpperCase();\n      const fieldDef = this.toFieldDefinition(model, globalProps);\n      const props = fieldDef.props as KeyValue;\n      if(!NgxRenderingEngine._operation)\n        NgxRenderingEngine._operation = props?.['operation'] || undefined;\n      result = this.fromFieldDefinition(fieldDef, vcr, injector, tpl, formId);\n\n      (result!.instance! as KeyValue)['formGroup'] = NgxFormService.getControlFromForm(formId);\n      NgxFormService.removeRegistry(formId);\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Failed to render Model ${model.constructor.name}: ${e}`,\n      );\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Initializes the rendering engine\n   * @summary This method initializes the rendering engine. It checks if the engine is already initialized\n   * and sets the initialized flag to true. This method is called before the engine is used\n   * to ensure it's properly set up for rendering operations.\n   *\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  override async initialize(): Promise<void> {\n    if (this.initialized)\n      return;\n    // ValidatableByType[]\n    this.initialized = true;\n  }\n\n  /**\n   * @description Registers a component with the rendering engine\n   * @summary This static method registers a component constructor with the rendering engine\n   * under a specific name. It initializes the components registry if needed and throws\n   * an error if a component is already registered under the same name to prevent\n   * accidental overrides.\n   *\n   * @param {string} name - The name to register the component under\n   * @param {Constructor<unknown>} constructor - The component constructor\n   * @return {void}\n   */\n  static registerComponent(name: string, constructor: Constructor<unknown>): void {\n    if (!this._components) this._components = {};\n    if (name in this._components)\n      throw new InternalError(`Component already registered under ${name}`);\n    this._components[name] = {\n      constructor: constructor,\n    };\n  }\n\n  /**\n   * @description Retrieves registered components from the rendering engine\n   * @summary This static method retrieves either all registered components or a specific component\n   * by its selector. When called without a selector, it returns an array of all registered\n   * components. When called with a selector, it returns the specific component if found,\n   * or throws an error if the component is not registered.\n   *\n   * @param {string} [selector] - Optional selector to retrieve a specific component\n   * @return {Object|Array} Either a specific component or an array of all components\n   */\n  static components(selector?: string): object | string[] {\n    if (!selector) return Object.values(this._components);\n    if (!(selector in this._components))\n      throw new InternalError(`No Component registered under ${selector}`);\n    return this._components[selector];\n  }\n\n  /**\n   * @description Generates a key for reflection metadata\n   * @summary This static method generates a key for reflection metadata by prefixing the input key\n   * with the Angular engine's reflection prefix. This is used for storing and retrieving\n   * metadata in a namespaced way to avoid conflicts with other metadata.\n   *\n   * @param {string} key - The base key to prefix\n   * @return {string} The prefixed key for reflection metadata\n   */\n  static override key(key: string): string {\n    return `${AngularEngineKeys.REFLECT}${key}`;\n  }\n\n  /**\n   * @description Sets input properties on a component instance\n   * @summary This static utility method sets input properties on a component instance\n   * based on the provided inputs object and component metadata. It handles both simple\n   * values and nested objects, recursively processing object properties. The method\n   * validates each input against the component's metadata to ensure only valid inputs\n   * are set.\n   *\n   * @param {ComponentRef<unknown>} component - The component reference to set inputs on\n   * @param {KeyValue} inputs - The input properties to set\n   * @param {ComponentMirror<unknown>} metadata - The component metadata for input validation\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant SetInputs as setInputs\n   *   participant Parse as parseInputValue\n   *   participant Component as ComponentRef\n   *\n   *   Caller->>SetInputs: setInputs(component, inputs, metadata)\n   *   SetInputs->>SetInputs: Iterate through inputs\n   *   loop For each input\n   *     SetInputs->>SetInputs: Check if input exists in metadata\n   *     alt Input is 'props'\n   *       SetInputs->>Parse: parseInputValue(component, value)\n   *       Parse->>Parse: Recursively process nested objects\n   *       Parse->>Component: setInput(key, value)\n   *     else Input is valid\n   *       SetInputs->>Component: setInput(key, value)\n   *     end\n   *   end\n   */\n  static setInputs(component: ComponentRef<unknown>, inputs: KeyValue, metadata: ComponentMirror<unknown>): void {\n    function parseInputValue(component: ComponentRef<unknown>, input: KeyValue) {\n      Object.keys(input).forEach(key => {\n        const value = input[key];\n        if (typeof value === 'object' && !!value)\n          return parseInputValue(component, value);\n        component.setInput(key, value);\n      });\n    }\n\n    Object.entries(inputs).forEach(([key, value]) => {\n      const prop = metadata.inputs.find((item: { propName: string }) => item.propName === key);\n      if (prop) {\n        if (key === 'props')\n          parseInputValue(component, value);\n        // if(key === 'locale' && !value)\n        //   value = getLocaleFromClassName(this._componentName);\n        component.setInput(key, value);\n      }\n    });\n  }\n}\n"]}

package/esm2022/engine/ValidatorFactory.mjs

@@ -1,7 +1,8 @@
 import { FormControl, FormGroup } from '@angular/forms';
-import { ComparisonValidationKeys, DEFAULT_PATTERNS, PathProxyEngine, Primitives, Validation, ValidationKeys, } from '@decaf-ts/decorator-validation';
+import { ComparisonValidationKeys, DEFAULT_PATTERNS, PathProxyEngine, Validation, ValidationKeys, } from '@decaf-ts/decorator-validation';
 import { HTML5InputTypes, parseValueByType } from '@decaf-ts/ui-decorators';
 import { AngularEngineKeys } from './constants';
+import { NgxRenderingEngine } from './NgxRenderingEngine';
 /**
  *
  * Resolves the correct validator key and its associated properties based on the input key and type.
@@ -25,7 +26,8 @@ const resolveValidatorKeyProps = (key, value, type) => {
     const isTypeBased = key === ValidationKeys.TYPE && Object.keys(patternValidators).includes(type);
     const validatorKey = isTypeBased ? type : key;
     const props = {
-        [validatorKey]: value,
+        // [validatorKey]: (!isTypeBased && key === 'type') ? parseType(type) : value,
+        [validatorKey]: (!isTypeBased && validatorKey === ValidationKeys.TYPE) ? NgxRenderingEngine.get().translate(value, false) : value,
         // Email, Password, and URL are validated using the "pattern" key
         ...(isTypeBased && { [ValidationKeys.PATTERN]: patternValidators[type] }),
     };
@@ -52,7 +54,7 @@ export class ValidatorFactory {
             let errs;
             try {
                 if (!props['types'] && !props['customTypes'])
-                    props['types'] = props['type'] === 'text' ? Primitives.STRING : type;
+                    props['types'] = props['type'];
                 errs = validator.hasErrors(value, props, proxy);
             }
             catch (e) {
@@ -101,4 +103,4 @@ export class ValidatorFactory {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ValidatorFactory.js","sourceRoot":"","sources":["../../../../src/lib/engine/ValidatorFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, FormControl, FormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';\nimport {\n  ComparisonValidationKeys,\n  DEFAULT_PATTERNS,\n  PathProxy,\n  PathProxyEngine,\n  Primitives,\n  Validation,\n  ValidationKeys,\n  Validator,\n} from '@decaf-ts/decorator-validation';\nimport { FieldProperties, HTML5InputTypes, parseValueByType } from '@decaf-ts/ui-decorators';\nimport { AngularEngineKeys } from './constants';\nimport { KeyValue } from './types';\n\ntype ComparisonValidationKey = typeof ComparisonValidationKeys[keyof typeof ComparisonValidationKeys];\n\n/**\n *\n * Resolves the correct validator key and its associated properties based on the input key and type.\n *\n * When the validation key is TYPE, it's necessary to resolve the actual validator based on the\n * field's type (e.g., 'password', 'email', 'url') instead of using the generic getValidator(\"type\") logic.\n * This allows directly invoking specific validators like getValidator('password'), ensuring the correct\n * behavior for type-based validation.\n *\n * @param key - The validation key (e.g., 'type', 'required', etc.).\n * @param value - The value that needs be provided to the validator.\n * @param type - The field's declared type.\n * @returns An object containing the resolved validator key and its corresponding props.\n */\nconst resolveValidatorKeyProps = (key: string, value: unknown, type: string): {\n  validatorKey: string;\n  props: Record<string, unknown>;\n} => {\n  const patternValidators: Record<string, unknown> = {\n    [ValidationKeys.PASSWORD]: DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n    [ValidationKeys.EMAIL]: DEFAULT_PATTERNS.EMAIL,\n    [ValidationKeys.URL]: DEFAULT_PATTERNS.URL,\n  };\n\n  const isTypeBased = key === ValidationKeys.TYPE && Object.keys(patternValidators).includes(type);\n  const validatorKey = isTypeBased ? type : key;\n  const props: Record<string, unknown> = {\n    [validatorKey]: value,\n    // Email, Password, and URL are validated using the \"pattern\" key\n    ...(isTypeBased && { [ValidationKeys.PATTERN]: patternValidators[type] }),\n  };\n\n  return { validatorKey, props };\n};\n\n\nexport class ValidatorFactory {\n  static spawn(fieldProps: FieldProperties, key: string): ValidatorFn {\n    if (!Validation.keys().includes(key))\n      throw new Error('Unsupported custom validation');\n\n    const validatorFn: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n      const { name, type } = fieldProps;\n      const { validatorKey, props } = resolveValidatorKeyProps(key, fieldProps[key as keyof FieldProperties], type);\n      const validator = Validation.get(validatorKey) as Validator;\n\n      // parseValueByType does not support undefined values\n      const value = typeof control.value !== 'undefined'\n        ? parseValueByType(type, type === HTML5InputTypes.CHECKBOX ? name : control.value, fieldProps)\n        : undefined;\n\n      // Create a proxy to enable access to parent and child values\n      let proxy: PathProxy<unknown> = ValidatorFactory.createProxy({} as AbstractControl);\n      if (Object.values(ComparisonValidationKeys).includes(key as ComparisonValidationKey)) {\n        const parent: FormGroup = control instanceof FormGroup ? control : (control as KeyValue)[AngularEngineKeys.PARENT];\n        proxy = ValidatorFactory.createProxy(parent) as PathProxy<unknown>;\n      }\n\n      let errs: string | undefined;\n      try {\n        if(!props['types'] && !props['customTypes'])\n          props['types'] = props['type'] === 'text' ? Primitives.STRING : type;\n        errs = validator.hasErrors(value, props, proxy);\n      } catch (e: unknown) {\n        errs = `${key} validator failed to validate: ${e}`;\n        console.warn(errs);\n      }\n\n      return errs ? { [validatorKey]: true } : null;\n    };\n\n    Object.defineProperty(validatorFn, 'name', {\n      value: `${key}Validator`,\n    });\n\n    return validatorFn;\n  }\n\n  /**\n   * @summary Creates a proxy wrapper for an Angular AbstractControl to assist with custom validation logic.\n   * @description Returns a structured proxy object that simulates a hierarchical tree of form values.\n   * Enables Validators handling method to access parent and child properties using consistent dot-notation in Angular forms.\n   *\n   * @param {AbstractControl} control - The control to wrap in a proxy.\n   * @returns {PathProxy<unknown>} A proxy object exposing form values and enabling recursive parent access.\n   */\n  static createProxy(control: AbstractControl): PathProxy<unknown> {\n    return PathProxyEngine.create(control, {\n      getValue(target: AbstractControl, prop: string): unknown {\n        if (target instanceof FormControl)\n          return target.value;\n\n        if (target instanceof FormGroup) {\n          const control = target.controls[prop];\n          return control instanceof FormControl ? control.value : control;\n        }\n\n        // const value = target[prop];\n        // if (value instanceof FormControl)\n        //   return value.value;\n        //\n        // if (value instanceof FormGroup) {\n        //   const control = value.controls[prop];\n        //   return control instanceof FormControl ? control.value : control;\n        // }\n\n        return (target as KeyValue)?.[prop];\n      },\n      getParent: function(target: AbstractControl)  {\n        return target?.['_parent'];\n      },\n      ignoreUndefined: true,\n      ignoreNull: true,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ValidatorFactory.js","sourceRoot":"","sources":["../../../../src/lib/engine/ValidatorFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, FormControl, FormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';\nimport {\n  ComparisonValidationKeys,\n  DEFAULT_PATTERNS,\n  PathProxy,\n  PathProxyEngine,\n  Validation,\n  ValidationKeys,\n  Validator,\n} from '@decaf-ts/decorator-validation';\nimport { FieldProperties, HTML5InputTypes, parseValueByType } from '@decaf-ts/ui-decorators';\nimport { AngularEngineKeys } from './constants';\nimport { KeyValue } from './types';\nimport { NgxRenderingEngine } from './NgxRenderingEngine';\n\n\ntype ComparisonValidationKey = typeof ComparisonValidationKeys[keyof typeof ComparisonValidationKeys];\n\n/**\n *\n * Resolves the correct validator key and its associated properties based on the input key and type.\n *\n * When the validation key is TYPE, it's necessary to resolve the actual validator based on the\n * field's type (e.g., 'password', 'email', 'url') instead of using the generic getValidator(\"type\") logic.\n * This allows directly invoking specific validators like getValidator('password'), ensuring the correct\n * behavior for type-based validation.\n *\n * @param key - The validation key (e.g., 'type', 'required', etc.).\n * @param value - The value that needs be provided to the validator.\n * @param type - The field's declared type.\n * @returns An object containing the resolved validator key and its corresponding props.\n */\nconst resolveValidatorKeyProps = (key: string, value: unknown, type: string): {\n  validatorKey: string;\n  props: Record<string, unknown>;\n} => {\n  const patternValidators: Record<string, unknown> = {\n    [ValidationKeys.PASSWORD]: DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n    [ValidationKeys.EMAIL]: DEFAULT_PATTERNS.EMAIL,\n    [ValidationKeys.URL]: DEFAULT_PATTERNS.URL,\n  };\n  const isTypeBased = key === ValidationKeys.TYPE && Object.keys(patternValidators).includes(type);\n  const validatorKey = isTypeBased ? type : key;\n  const props: Record<string, unknown> = {\n    // [validatorKey]: (!isTypeBased && key === 'type') ? parseType(type) : value,\n    [validatorKey]: (!isTypeBased && validatorKey === ValidationKeys.TYPE) ? NgxRenderingEngine.get().translate(value as string, false) : value,\n    // Email, Password, and URL are validated using the \"pattern\" key\n    ...(isTypeBased && { [ValidationKeys.PATTERN] : patternValidators[type] }),\n  };\n\n  return { validatorKey, props };\n};\n\n\nexport class ValidatorFactory {\n  static spawn(fieldProps: FieldProperties, key: string): ValidatorFn {\n    if (!Validation.keys().includes(key))\n      throw new Error('Unsupported custom validation');\n\n    const validatorFn: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n      const { name, type } = fieldProps;\n      const { validatorKey, props } = resolveValidatorKeyProps(key, fieldProps[key as keyof FieldProperties], type);\n      const validator = Validation.get(validatorKey) as Validator;\n\n      // parseValueByType does not support undefined values\n      const value = typeof control.value !== 'undefined'\n        ? parseValueByType(type, type === HTML5InputTypes.CHECKBOX ? name : control.value, fieldProps)\n        : undefined;\n\n      // Create a proxy to enable access to parent and child values\n      let proxy: PathProxy<unknown> = ValidatorFactory.createProxy({} as AbstractControl);\n      if (Object.values(ComparisonValidationKeys).includes(key as ComparisonValidationKey)) {\n        const parent: FormGroup = control instanceof FormGroup ? control : (control as KeyValue)[AngularEngineKeys.PARENT];\n        proxy = ValidatorFactory.createProxy(parent) as PathProxy<unknown>;\n      }\n\n      let errs: string | undefined;\n      try {\n        if(!props['types'] && !props['customTypes'])\n          props['types'] = props['type'];\n        errs = validator.hasErrors(value, props, proxy);\n      } catch (e: unknown) {\n        errs = `${key} validator failed to validate: ${e}`;\n        console.warn(errs);\n      }\n\n      return errs ? { [validatorKey]: true } : null;\n    };\n\n    Object.defineProperty(validatorFn, 'name', {\n      value: `${key}Validator`,\n    });\n\n    return validatorFn;\n  }\n\n  /**\n   * @summary Creates a proxy wrapper for an Angular AbstractControl to assist with custom validation logic.\n   * @description Returns a structured proxy object that simulates a hierarchical tree of form values.\n   * Enables Validators handling method to access parent and child properties using consistent dot-notation in Angular forms.\n   *\n   * @param {AbstractControl} control - The control to wrap in a proxy.\n   * @returns {PathProxy<unknown>} A proxy object exposing form values and enabling recursive parent access.\n   */\n  static createProxy(control: AbstractControl): PathProxy<unknown> {\n    return PathProxyEngine.create(control, {\n      getValue(target: AbstractControl, prop: string): unknown {\n        if (target instanceof FormControl)\n          return target.value;\n\n        if (target instanceof FormGroup) {\n          const control = target.controls[prop];\n          return control instanceof FormControl ? control.value : control;\n        }\n\n        // const value = target[prop];\n        // if (value instanceof FormControl)\n        //   return value.value;\n        //\n        // if (value instanceof FormGroup) {\n        //   const control = value.controls[prop];\n        //   return control instanceof FormControl ? control.value : control;\n        // }\n\n        return (target as KeyValue)?.[prop];\n      },\n      getParent: function(target: AbstractControl)  {\n        return target?.['_parent'];\n      },\n      ignoreUndefined: true,\n      ignoreNull: true,\n    });\n  }\n}\n"]}