@decaf-ts/for-angular 0.0.3 → 0.0.5

package/dist/lib/esm2022/engine/NgxFormService.mjs

@@ -0,0 +1,315 @@
+import { escapeHtml, HTML5CheckTypes, HTML5InputTypes, parseToNumber } from '@decaf-ts/ui-decorators';
+import { FormControl, FormGroup, Validators } from '@angular/forms';
+import { isValidDate, parseDate, Validation } from '@decaf-ts/decorator-validation';
+import { ValidatorFactory } from './ValidatorFactory';
+/**
+ * @description Service for managing Angular forms and form controls.
+ * @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.
+ *
+ * @class
+ * @param {WeakMap<AbstractControl, FieldProperties>} controls - A WeakMap to store control properties.
+ * @param {Map<string, FormGroup>} formRegistry - A Map to store registered forms.
+ *
+ * @example
+ * // Creating a form from components
+ * const components = [
+ *   { inputs: { name: 'username', type: 'text', required: true } },
+ *   { inputs: { name: 'password', type: 'password', minLength: 8 } }
+ * ];
+ * const form = NgxFormService.createFormFromComponents('loginForm', components, true);
+ *
+ * // Validating fields
+ * NgxFormService.validateFields(form);
+ *
+ * // Getting form data
+ * const formData = NgxFormService.getFormData(form);
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Component
+ *   participant NFS as NgxFormService
+ *   participant AF as Angular Forms
+ *   C->>NFS: createFormFromComponents()
+ *   NFS->>AF: new FormGroup()
+ *   NFS->>NFS: addFormControl()
+ *   NFS->>AF: addControl()
+ *   NFS-->>C: Return FormGroup
+ *   C->>NFS: validateFields()
+ *   NFS->>AF: markAsTouched(), markAsDirty(), updateValueAndValidity()
+ *   C->>NFS: getFormData()
+ *   NFS->>AF: Get control values
+ *   NFS-->>C: Return form data
+ */
+export class NgxFormService {
+    static { this.controls = new WeakMap(); }
+    static { this.formRegistry = new Map(); }
+    /**
+     * @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.
+     */
+    static addRegistry(formId, formGroup) {
+        if (this.formRegistry.has(formId))
+            throw new Error(`A FormGroup with id '${formId}' is already registered.`);
+        this.formRegistry.set(formId, formGroup);
+    }
+    /**
+     * @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.
+     */
+    static removeRegistry(formId) {
+        this.formRegistry.delete(formId);
+    }
+    /**
+     * @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.
+     */
+    static resolveParentGroup(formGroup, path) {
+        const parts = path.split('.');
+        const controlName = parts.pop();
+        let currentGroup = formGroup;
+        for (const part of parts) {
+            if (!currentGroup.get(part)) {
+                currentGroup.addControl(part, new FormGroup({}));
+            }
+            currentGroup = currentGroup.get(part);
+        }
+        return [currentGroup, controlName];
+    }
+    /**
+     * @description Adds a form control to a form group.
+     * @summary Creates and adds a form control to the specified form group based on the provided component properties.
+     * @param {FormGroup} formGroup - The form group to add the control to.
+     * @param {ComponentInput} componentProps - The properties of the component to create the control from.
+     */
+    static addFormControl(formGroup, componentProps) {
+        const { name, childOf } = componentProps;
+        const fullPath = childOf ? `${childOf}.${name}` : name;
+        const [parentGroup, controlName] = this.resolveParentGroup(formGroup, fullPath);
+        if (!parentGroup.get(controlName)) {
+            const control = NgxFormService.fromProps(componentProps, componentProps.updateMode || 'change');
+            NgxFormService.register(control, componentProps);
+            parentGroup.addControl(controlName, control);
+        }
+        componentProps['formGroup'] = parentGroup;
+        componentProps['formControl'] = parentGroup.get(controlName);
+    }
+    /**
+     * @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.
+     */
+    static getControlFromForm(formId, path) {
+        const form = this.formRegistry.get(formId);
+        if (!form)
+            throw new Error(`Form with id '${formId}' not found in the registry.`);
+        if (!path)
+            return form;
+        const control = form.get(path);
+        if (!control)
+            throw new Error(`Control with path '${path}' not found in form '${formId}'.`);
+        return control;
+    }
+    /**
+     * @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 {ComponentConfig[]} components - An array of component configurations.
+     * @param {boolean} [registry=false] - Whether to register the created form.
+     * @return {FormGroup} The created FormGroup.
+     */
+    static createFormFromComponents(id, components, registry = false) {
+        const form = new FormGroup({});
+        components.forEach(component => {
+            this.addFormControl(form, component.inputs);
+        });
+        if (registry)
+            this.addRegistry(id, form);
+        return form;
+    }
+    /**
+     * @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.
+     */
+    static addControlFromProps(id, componentProperties) {
+        const form = this.formRegistry.get(id) ?? new FormGroup({});
+        if (!this.formRegistry.has(id))
+            this.addRegistry(id, form);
+        if (componentProperties.path)
+            this.addFormControl(form, componentProperties);
+        return form;
+    }
+    /**
+     * @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.
+     */
+    static getFormData(formGroup) {
+        const data = {};
+        for (const key in formGroup.controls) {
+            const control = formGroup.controls[key];
+            if (!(control instanceof FormControl)) {
+                data[key] = NgxFormService.getFormData(control);
+                continue;
+            }
+            const props = NgxFormService.getPropsFromControl(control);
+            let value = control.value;
+            if (!HTML5CheckTypes.includes(props['type'])) {
+                switch (props['type']) {
+                    case HTML5InputTypes.NUMBER:
+                        value = parseToNumber(value);
+                        break;
+                    case HTML5InputTypes.DATE:
+                    case HTML5InputTypes.DATETIME_LOCAL:
+                        value = new Date(value);
+                        break;
+                    default:
+                        value = escapeHtml(value);
+                }
+            }
+            data[key] = value;
+        }
+        return data;
+    }
+    /**
+     * @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.
+     */
+    static validateFields(control, path) {
+        control = path ? control.get(path) : control;
+        if (!control)
+            throw new Error(`No control found at path: ${path || 'root'}.`);
+        const isAllowed = [FormGroup, FormControl].some(type => control instanceof type);
+        if (!isAllowed)
+            throw new Error(`Unknown control type at: ${path || 'root'}`);
+        control.markAsTouched();
+        control.markAsDirty();
+        control.updateValueAndValidity({ emitEvent: true });
+        if (control instanceof FormGroup) {
+            Object.values(control.controls).forEach((childControl) => {
+                this.validateFields(childControl);
+            });
+        }
+        return control.valid;
+    }
+    /**
+     * @description Generates validators from component properties.
+     * @summary Creates an array of ValidatorFn based on the supported validation keys in the component properties.
+     * @param {FieldProperties} props - The component properties.
+     * @return {ValidatorFn[]} An array of validator functions.
+     */
+    static validatorsFromProps(props) {
+        const supportedValidationKeys = Validation.keys();
+        return Object.keys(props)
+            .filter((k) => supportedValidationKeys.includes(k))
+            .map((k) => {
+            return ValidatorFactory.spawn(props, k);
+        });
+    }
+    /**
+     * @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.
+     */
+    static fromProps(props, updateMode = 'change') {
+        const validators = this.validatorsFromProps(props);
+        const composed = validators.length ? Validators.compose(validators) : null;
+        return new FormControl({
+            value: props.value && props.type !== HTML5InputTypes.CHECKBOX
+                ? props.type === HTML5InputTypes.DATE
+                    ? !isValidDate(parseDate(props.format, props.value))
+                        ? undefined : props.value :
+                    props.value : undefined,
+            disabled: props.disabled,
+        }, {
+            validators: composed,
+            updateOn: updateMode,
+        });
+    }
+    /**
+     * @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.
+     */
+    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.
+     */
+    static getParentEl(el, tag) {
+        let parent;
+        while ((parent = el.parentElement) !== null) {
+            if (parent.tagName.toLowerCase() === tag.toLowerCase()) {
+                return parent;
+            }
+            el = parent;
+        }
+        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.
+     */
+    static register(control, props) {
+        this.controls.set(control, props);
+    }
+    /**
+     * @description Unregisters a control.
+     * @summary Removes a control and its associated properties from the internal WeakMap.
+     * @param {AbstractControl} control - The control to unregister.
+     * @return {boolean} True if the control was successfully unregistered, false otherwise.
+     */
+    static unregister(control) {
+        return this.controls.delete(control);
+    }
+    /**
+     * @description Resets a form group.
+     * @summary Recursively resets all controls in a form group, clearing values, errors, and marking them as pristine and untouched.
+     * @param {FormGroup} formGroup - The form group to reset.
+     */
+    static reset(formGroup) {
+        for (const key in formGroup.controls) {
+            const control = formGroup.controls[key];
+            if (!(control instanceof FormControl)) {
+                NgxFormService.reset(control);
+                continue;
+            }
+            const { type } = NgxFormService.getPropsFromControl(control);
+            if (!HTML5CheckTypes.includes(type))
+                control.setValue(undefined);
+            control.markAsPristine();
+            control.markAsUntouched();
+            control.setErrors(null);
+            control.updateValueAndValidity();
+        }
+    }
+}
+//# 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 {  ComponentConfig, ComponentInput, FieldUpdateMode, FormParentGroup } from './types';\nimport { AbstractControl, FormControl, FormGroup, ValidatorFn, Validators } from '@angular/forms';\nimport { isValidDate, parseDate, Validation } from '@decaf-ts/decorator-validation';\nimport { ValidatorFactory } from './ValidatorFactory';\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  private static controls = new WeakMap<AbstractControl, FieldProperties>();\n  private static formRegistry = new Map<string, FormGroup>();\n\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): FormParentGroup {\n    const parts = path.split('.');\n    const controlName = parts.pop() as string;\n    let currentGroup = formGroup;\n    for (const part of parts) {\n      if (!currentGroup.get(part)) {\n        currentGroup.addControl(part, new FormGroup({}));\n      }\n      currentGroup = currentGroup.get(part) as FormGroup;\n    }\n    return [currentGroup, controlName];\n  }\n\n  /**\n   * @description Adds a form control to a form group.\n   * @summary Creates and adds a form control to the specified form group based on the provided component properties.\n   * @param {FormGroup} formGroup - The form group to add the control to.\n   * @param {ComponentInput} componentProps - The properties of the component to create the control from.\n   */\n  private static addFormControl(formGroup: FormGroup, componentProps: ComponentInput): void {\n\n    const { name, childOf } = componentProps;\n    const fullPath = childOf ? `${childOf}.${name}` : name;\n    const [parentGroup, controlName] = this.resolveParentGroup(formGroup, fullPath);\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  }\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 {ComponentConfig[]} 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: ComponentConfig[], registry = 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): 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);\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      if (!(control instanceof FormControl)) {\n        data[key] = NgxFormService.getFormData(control as FormGroup);\n        continue;\n      }\n\n      const props = NgxFormService.getPropsFromControl(control);\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\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, 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 = [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    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 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 any) : 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): 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) {\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) {\n    for (const key in formGroup.controls) {\n      const control = formGroup.controls[key];\n      if (!(control instanceof FormControl)) {\n        NgxFormService.reset(control as FormGroup);\n        continue;\n      }\n\n      const { type } = NgxFormService.getPropsFromControl(control);\n      if (!HTML5CheckTypes.includes(type))\n        control.setValue(undefined);\n      control.markAsPristine();\n      control.markAsUntouched();\n      control.setErrors(null);\n      control.updateValueAndValidity();\n    }\n  }\n}\n"]}

package/dist/lib/esm2022/engine/NgxRenderingEngine.mjs

@@ -0,0 +1,194 @@
+import { RenderingEngine } from '@decaf-ts/ui-decorators';
+import { AngularEngineKeys } from './constants';
+import { InternalError } from '@decaf-ts/db-decorators';
+import { reflectComponentType, } from '@angular/core';
+/**
+ * @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.
+ * @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();
+ * 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: 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
+ */
+export class NgxRenderingEngine extends RenderingEngine {
+    constructor() {
+        super('angular');
+    }
+    /**
+     * @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.
+     * @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
+     * @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
+     *
+     *   Method->>Components: components(fieldDef.tag)
+     *   Components-->>Method: component constructor
+     *   Method->>Angular: reflectComponentType(component)
+     *   Angular-->>Method: componentMetadata
+     *   Method->>Method: Check input properties
+     *   Method->>Method: Create result object
+     *   Method->>Method: Process children if any
+     *   Method-->>Caller: return AngularDynamicOutput
+     */
+    fromFieldDefinition(fieldDef, vcr, injector, tpl) {
+        const component = NgxRenderingEngine.components(fieldDef.tag)
+            .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 result = {
+            component: component,
+            inputs: inputs || {},
+            injector: injector,
+        };
+        if (fieldDef.rendererId) {
+            result.inputs['rendererId'] =
+                fieldDef.rendererId;
+        }
+        if (fieldDef.children && fieldDef.children.length) {
+            result.children = fieldDef.children.map((child) => {
+                return this.fromFieldDefinition(child, vcr, injector, tpl);
+            });
+            const template = vcr.createEmbeddedView(tpl, injector).rootNodes;
+            result.content = [template];
+        }
+        return result;
+    }
+    /**
+     * @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.
+     * @template M - Type extending Model
+     * @param {M} model - The model to render
+     * @param {Record<string, unknown>} globalProps - Global properties to pass to the component
+     * @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
+     * @return {AngularDynamicOutput} The Angular component output with component reference and inputs
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client as Client Code
+     *   participant Render as render method
+     *   participant ToField as toFieldDefinition
+     *   participant FromField as fromFieldDefinition
+     *
+     *   Client->>Render: render(model, globalProps, vcr, injector, tpl)
+     *   Render->>ToField: toFieldDefinition(model, globalProps)
+     *   ToField-->>Render: fieldDef
+     *   Render->>FromField: fromFieldDefinition(fieldDef, vcr, injector, tpl)
+     *   FromField-->>Render: AngularDynamicOutput
+     *   Render-->>Client: return AngularDynamicOutput
+     */
+    render(model, globalProps, vcr, injector, tpl) {
+        let result;
+        try {
+            const fieldDef = this.toFieldDefinition(model, globalProps);
+            result = this.fromFieldDefinition(fieldDef, vcr, injector, tpl);
+        }
+        catch (e) {
+            throw new InternalError(`Failed to render Model ${model.constructor.name}: ${e}`);
+        }
+        return result;
+    }
+    /**
+     * @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.
+     * @param {...any[]} args - Initialization arguments
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     */
+    async initialize(...args) {
+        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.
+     * @param {string} name - The name to register the component under
+     * @param {Constructor<unknown>} constructor - The component constructor
+     * @return {void}
+     */
+    static registerComponent(name, constructor) {
+        if (!this._components)
+            this._components = {};
+        if (name in this._components)
+            throw new InternalError(`Component already registered under ${name}`);
+        this._components[name] = {
+            constructor: constructor,
+        };
+    }
+    /**
+     * @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.
+     * @param {string} [selector] - Optional selector to retrieve a specific component
+     * @return {Object|Array} Either a specific component or an array of all components
+     */
+    static components(selector) {
+        if (!selector)
+            return Object.values(this._components);
+        if (!(selector in this._components))
+            throw new InternalError(`No Component registered under ${selector}`);
+        return this._components[selector];
+    }
+    /**
+     * @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.
+     * @param {string} key - The base key to prefix
+     * @return {string} The prefixed key for reflection metadata
+     */
+    static key(key) {
+        return `${AngularEngineKeys.REFLECT}${key}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxRenderingEngine.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxRenderingEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAEL,oBAAoB,GAIrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,OAAO,kBAAmB,SAAQ,eAGvC;IAMC;QACE,KAAK,CAAC,SAAS,CAAC,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACK,mBAAmB,CACzB,QAAiD,EACjD,GAAqB,EACrB,QAAkB,EAClB,GAAqB;QAErB,MAAM,SAAS,GAAG,kBAAkB,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC;aAC1D,WAAuC,CAAC;QAE3C,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC1D,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,aAAa,CACrB,0BAA0B,QAAQ,CAAC,GAAG,aAAa,CACpD,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC;QAE9B,MAAM,cAAc,GAAG,iBAAiB,CAAC,MAAM,CAAC;QAChD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtC,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;YACnC,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAChD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7B,CAAC;YACD,IAAI,CAAC,SAAS,CAAC,MAAM;gBAAE,MAAM;QAC/B,CAAC;QAED,IAAI,SAAS,CAAC,MAAM;YAClB,OAAO,CAAC,IAAI,CACV,2CAA2C,QAAQ,CAAC,GAAG,KAAK,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACnF,CAAC;QAEJ,MAAM,MAAM,GAAyB;YACnC,SAAS,EAAE,SAAS;YACpB,MAAM,EAAE,MAAM,IAAI,EAAE;YACpB,QAAQ,EAAE,QAAQ;SACnB,CAAC;QAEF,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YACvB,MAAM,CAAC,MAA8B,CAAC,YAAY,CAAC;gBAClD,QAAQ,CAAC,UAAU,CAAC;QACxB,CAAC;QAED,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAClD,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;gBAChD,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC7D,CAAC,CAAC,CAAC;YAEH,MAAM,QAAQ,GAAG,GAAG,CAAC,kBAAkB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,SAAS,CAAC;YACjE,MAAM,CAAC,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACM,MAAM,CACb,KAAQ,EACR,WAAoC,EACpC,GAAqB,EACrB,QAAkB,EAClB,GAAqB;QAErB,IAAI,MAA4B,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAC5D,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QAClE,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,aAAa,CACrB,0BAA0B,KAAK,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE,CACzD,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACM,KAAK,CAAC,UAAU,CAAC,GAAG,IAAW;QACtC,IAAI,IAAI,CAAC,WAAW;YAAE,OAAO;QAC7B,sBAAsB;QACtB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAY,EAAE,WAAiC;QACtE,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QAC7C,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW;YAC1B,MAAM,IAAI,aAAa,CAAC,sCAAsC,IAAI,EAAE,CAAC,CAAC;QACxE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG;YACvB,WAAW,EAAE,WAAW;SACzB,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,QAAiB;QACjC,IAAI,CAAC,QAAQ;YAAE,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtD,IAAI,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,WAAW,CAAC;YACjC,MAAM,IAAI,aAAa,CAAC,iCAAiC,QAAQ,EAAE,CAAC,CAAC;QACvE,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAU,GAAG,CAAC,GAAW;QAC7B,OAAO,GAAG,iBAAiB,CAAC,OAAO,GAAG,GAAG,EAAE,CAAC;IAC9C,CAAC;CACF","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<any>,\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, any>)['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<any>,\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   * @param {...any[]} args - Initialization arguments\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  override async initialize(...args: any[]): Promise<void> {\n    if (this.initialized) 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 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"]}