@decaf-ts/for-angular 0.0.4 → 0.0.6

package/dist/lib/esm2022/components/component-renderer/component-renderer.component.mjs

@@ -0,0 +1,312 @@
+import { Component, EnvironmentInjector, EventEmitter, inject, Input, Output, reflectComponentType, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { NgxRenderingEngine2 } from 'src/lib/engine/NgxRenderingEngine2';
+import { ForAngularModule, getLogger } from 'src/lib/for-angular.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @description Dynamic component renderer for Decaf Angular applications.
+ * @summary This component provides a flexible way to dynamically render Angular components
+ * at runtime based on a tag name. It handles the creation, property binding, and event
+ * subscription for dynamically loaded components. This is particularly useful for
+ * building configurable UIs where components need to be determined at runtime.
+ *
+ * @component {ComponentRendererComponent}
+ * @example
+ * <ngx-decaf-component-renderer
+ *   [tag]="tag"
+ *   [globals]="globals"
+ *   (listenEvent)="listenEvent($event)">
+ * </ngx-decaf-component-renderer>
+ *
+ * @mermaid
+ * classDiagram
+ *   class ComponentRendererComponent {
+ *     +ViewContainerRef vcr
+ *     +string tag
+ *     +Record~string, unknown~ globals
+ *     +EnvironmentInjector injector
+ *     +ComponentRef~unknown~ component
+ *     +EventEmitter~ModelRenderCustomEvent~ listenEvent
+ *     +ngOnInit()
+ *     +ngOnDestroy()
+ *     +ngOnChanges(changes)
+ *     -createComponent(tag, globals)
+ *     -subscribeEvents()
+ *     -unsubscribeEvents()
+ *   }
+ *   ComponentRendererComponent --|> OnInit
+ *   ComponentRendererComponent --|> OnChanges
+ *   ComponentRendererComponent --|> OnDestroy
+ *
+ * @implements {OnInit}
+ * @implements {OnChanges}
+ * @implements {OnDestroy}
+ */
+export class ComponentRendererComponent {
+    /**
+     * @description Creates an instance of ComponentRendererComponent.
+     * @summary Initializes a new ComponentRendererComponent. This component doesn't require
+     * any dependencies to be injected in its constructor as it uses the inject function to
+     * obtain the EnvironmentInjector.
+     *
+     * @memberOf ComponentRendererComponent
+     */
+    constructor() {
+        /**
+         * @description Global properties to pass to the rendered component.
+         * @summary This input property allows passing a set of properties to the dynamically
+         * rendered component. These properties will be mapped to the component's inputs if they
+         * match. Properties that don't match any input on the target component will be filtered out
+         * with a warning.
+         *
+         * @type {Record<string, unknown>}
+         * @default {}
+         * @memberOf ComponentRendererComponent
+         */
+        this.globals = {};
+        /**
+         * @description Injector used for dependency injection in the dynamic component.
+         * @summary This injector is used when creating the dynamic component to provide it with
+         * access to the application's dependency injection system. It ensures that the dynamically
+         * created component can access the same services and dependencies as statically created
+         * components.
+         *
+         * @type {EnvironmentInjector}
+         * @memberOf ComponentRendererComponent
+         */
+        this.injector = inject(EnvironmentInjector);
+        /**
+         * @description Event emitter for events from the rendered component.
+         * @summary This output property emits events that originate from the dynamically rendered
+         * component. It allows the parent component to listen for and respond to events from the
+         * dynamic component, creating a communication channel between the parent and the dynamically
+         * rendered child.
+         *
+         * @type {EventEmitter<ModelRenderCustomEvent>}
+         * @memberOf ComponentRendererComponent
+         */
+        this.listenEvent = new EventEmitter();
+        this.parent = undefined;
+        this.logger = getLogger(this);
+    }
+    /**
+     * @description Initializes the component after Angular first displays the data-bound properties.
+     * @summary Sets up the component by creating the dynamic component specified by the tag input.
+     * This method is called once when the component is initialized and triggers the dynamic
+     * component creation process with the provided tag name and global properties.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant C as ComponentRendererComponent
+     *   participant R as NgxRenderingEngine2
+     *
+     *   A->>C: ngOnInit()
+     *   C->>C: createComponent(tag, globals)
+     *   C->>R: components(tag)
+     *   R-->>C: Return component constructor
+     *   C->>C: Process component inputs
+     *   C->>C: Create component instance
+     *   C->>C: subscribeEvents()
+     *
+     * @return {void}
+     * @memberOf ComponentRendererComponent
+     */
+    ngOnInit() {
+        if (!this.parent) {
+            this.createComponent(this.tag, this.globals);
+        }
+        else {
+            this.createParentComponent();
+        }
+    }
+    /**
+     * @description Cleans up resources when the component is destroyed.
+     * @summary Performs cleanup operations when the component is being destroyed by Angular.
+     * This includes unsubscribing from all event emitters of the dynamic component and
+     * destroying the rendering engine instance to prevent memory leaks.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant C as ComponentRendererComponent
+     *   participant R as NgxRenderingEngine2
+     *
+     *   A->>C: ngOnDestroy()
+     *   alt component exists
+     *     C->>C: unsubscribeEvents()
+     *     C->>R: destroy()
+     *   end
+     *
+     * @return {Promise<void>} A promise that resolves when cleanup is complete
+     * @memberOf ComponentRendererComponent
+     */
+    async ngOnDestroy() {
+        if (this.component) {
+            this.unsubscribeEvents();
+            NgxRenderingEngine2.destroy();
+        }
+    }
+    /**
+     * @description Creates and renders a dynamic component.
+     * @summary This method handles the creation of a dynamic component based on the provided tag.
+     * It retrieves the component constructor from the rendering engine, processes its inputs,
+     * filters out unmapped properties, creates the component instance, and sets up event subscriptions.
+     *
+     * @param {string} tag - The tag name of the component to create
+     * @param {KeyValue} globals - Global properties to pass to the component
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as ComponentRendererComponent
+     *   participant R as NgxRenderingEngine2
+     *   participant V as ViewContainerRef
+     *
+     *   C->>R: components(tag)
+     *   R-->>C: Return component constructor
+     *   C->>C: reflectComponentType(component)
+     *   C->>C: Process input properties
+     *   C->>C: Filter unmapped properties
+     *   C->>V: clear()
+     *   C->>R: createComponent(component, props, metadata, vcr, injector, [])
+     *   R-->>C: Return component reference
+     *   C->>C: subscribeEvents()
+     *
+     * @private
+     * @memberOf ComponentRendererComponent
+     */
+    createComponent(tag, globals = {}) {
+        const component = NgxRenderingEngine2.components(tag)
+            ?.constructor;
+        const metadata = reflectComponentType(component);
+        const componentInputs = metadata.inputs;
+        const props = globals?.['item'];
+        delete props['tag'];
+        const inputKeys = Object.keys(props);
+        const unmappedKeys = [];
+        for (const input of inputKeys) {
+            if (!inputKeys.length)
+                break;
+            const prop = componentInputs.find((item) => item.propName === input);
+            if (!prop) {
+                delete props[input];
+                unmappedKeys.push(input);
+            }
+        }
+        if (unmappedKeys.length)
+            this.logger.info(`Unmapped input properties for component ${tag}: ${unmappedKeys.join(', ')}`);
+        this.vcr.clear();
+        this.component = NgxRenderingEngine2.createComponent(component, props, metadata, this.vcr, this.injector, []);
+        this.subscribeEvents();
+    }
+    createParentComponent() {
+        const { component, inputs } = this.parent;
+        const metadata = reflectComponentType(component);
+        const template = this.vcr.createEmbeddedView(this.inner, this.injector).rootNodes;
+        this.component = NgxRenderingEngine2.createComponent(component, inputs, metadata, this.vcr, this.injector, template);
+        this.subscribeEvents();
+    }
+    /**
+     * @description Subscribes to events emitted by the dynamic component.
+     * @summary This method sets up subscriptions to all EventEmitter properties of the
+     * dynamically created component. When an event is emitted by the dynamic component,
+     * it is captured and re-emitted through the listenEvent output property with additional
+     * metadata about the event source.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as ComponentRendererComponent
+     *   participant D as Dynamic Component
+     *   participant P as Parent Component
+     *
+     *   C->>C: subscribeEvents()
+     *   C->>D: Get instance properties
+     *   loop For each property
+     *     C->>C: Check if property is EventEmitter
+     *     alt is EventEmitter
+     *       C->>D: Subscribe to event
+     *       D-->>C: Event emitted
+     *       C->>P: Re-emit event with metadata
+     *     end
+     *   end
+     *
+     * @private
+     * @return {void}
+     * @memberOf ComponentRendererComponent
+     */
+    subscribeEvents() {
+        if (this.component) {
+            const instance = this.component?.instance;
+            const componentKeys = Object.keys(instance);
+            for (const key of componentKeys) {
+                const value = instance[key];
+                if (value instanceof EventEmitter)
+                    instance[key].subscribe((event) => {
+                        this.listenEvent.emit({
+                            name: key,
+                            ...event,
+                        });
+                    });
+            }
+        }
+    }
+    /**
+     * @description Unsubscribes from all events of the dynamic component.
+     * @summary This method cleans up event subscriptions when the component is being destroyed.
+     * It iterates through all properties of the dynamic component instance and unsubscribes
+     * from any EventEmitter properties to prevent memory leaks and unexpected behavior after
+     * the component is destroyed.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as ComponentRendererComponent
+     *   participant D as Dynamic Component
+     *
+     *   C->>C: unsubscribeEvents()
+     *   C->>D: Get instance properties
+     *   loop For each property
+     *     C->>C: Check if property is EventEmitter
+     *     alt is EventEmitter
+     *       C->>D: Unsubscribe from event
+     *     end
+     *   end
+     *
+     * @private
+     * @return {void}
+     * @memberOf ComponentRendererComponent
+     */
+    unsubscribeEvents() {
+        if (this.component) {
+            const instance = this.component?.instance;
+            const componentKeys = Object.keys(instance);
+            for (const key of componentKeys) {
+                const value = instance[key];
+                if (value instanceof EventEmitter)
+                    instance[key].unsubscribe();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ComponentRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ComponentRendererComponent, isStandalone: true, selector: "ngx-decaf-component-renderer", inputs: { tag: "tag", globals: "globals", parent: "parent" }, outputs: { listenEvent: "listenEvent" }, viewQueries: [{ propertyName: "vcr", first: true, predicate: ["componentViewContainer"], descendants: true, read: ViewContainerRef, static: true }, { propertyName: "inner", first: true, predicate: ["inner"], descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: "<ng-template #componentViewContainer></ng-template>\n\n<ng-template #inner>\n  @if(parent?.children?.length) {\n    @for(child of parent.children; track child) {\n        @if(!child.children?.length) {\n          <ng-container\n                *ngComponentOutlet=\"\n                  child.component;\n                  injector: child.injector;\n                  inputs: child.inputs;\n                  content:child.content;\n                \"\n          />\n        } @else {\n          <ngx-decaf-component-renderer [parent]=\"child\"> </ngx-decaf-component-renderer>\n        }\n     }\n  }\n</ng-template>\n\n\n", styles: [""], dependencies: [{ kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "parent"], outputs: ["listenEvent"] }, { kind: "ngmodule", type: ForAngularModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ComponentRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-component-renderer', imports: [ForAngularModule], standalone: true, template: "<ng-template #componentViewContainer></ng-template>\n\n<ng-template #inner>\n  @if(parent?.children?.length) {\n    @for(child of parent.children; track child) {\n        @if(!child.children?.length) {\n          <ng-container\n                *ngComponentOutlet=\"\n                  child.component;\n                  injector: child.injector;\n                  inputs: child.inputs;\n                  content:child.content;\n                \"\n          />\n        } @else {\n          <ngx-decaf-component-renderer [parent]=\"child\"> </ngx-decaf-component-renderer>\n        }\n     }\n  }\n</ng-template>\n\n\n" }]
+        }], ctorParameters: () => [], propDecorators: { vcr: [{
+                type: ViewChild,
+                args: ['componentViewContainer', { static: true, read: ViewContainerRef }]
+            }], tag: [{
+                type: Input,
+                args: [{ required: true }]
+            }], globals: [{
+                type: Input
+            }], listenEvent: [{
+                type: Output
+            }], parent: [{
+                type: Input
+            }], inner: [{
+                type: ViewChild,
+                args: ['inner', { read: TemplateRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-renderer.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/component-renderer/component-renderer.component.ts","../../../../../src/lib/components/component-renderer/component-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ComponentMirror,\n  ComponentRef,\n  EnvironmentInjector,\n  EventEmitter,\n  inject,\n  Injector,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  reflectComponentType,\n  TemplateRef,\n  Type,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { NgxRenderingEngine2 } from 'src/lib/engine/NgxRenderingEngine2';\nimport { BaseCustomEvent, KeyValue, ModelRenderCustomEvent } from '../../engine';\nimport { ForAngularModule, getLogger } from 'src/lib/for-angular.module';\nimport { Logger } from '@decaf-ts/logging';\n\n/**\n * @description Dynamic component renderer for Decaf Angular applications.\n * @summary This component provides a flexible way to dynamically render Angular components\n * at runtime based on a tag name. It handles the creation, property binding, and event\n * subscription for dynamically loaded components. This is particularly useful for\n * building configurable UIs where components need to be determined at runtime.\n *\n * @component {ComponentRendererComponent}\n * @example\n * <ngx-decaf-component-renderer\n *   [tag]=\"tag\"\n *   [globals]=\"globals\"\n *   (listenEvent)=\"listenEvent($event)\">\n * </ngx-decaf-component-renderer>\n *\n * @mermaid\n * classDiagram\n *   class ComponentRendererComponent {\n *     +ViewContainerRef vcr\n *     +string tag\n *     +Record~string, unknown~ globals\n *     +EnvironmentInjector injector\n *     +ComponentRef~unknown~ component\n *     +EventEmitter~ModelRenderCustomEvent~ listenEvent\n *     +ngOnInit()\n *     +ngOnDestroy()\n *     +ngOnChanges(changes)\n *     -createComponent(tag, globals)\n *     -subscribeEvents()\n *     -unsubscribeEvents()\n *   }\n *   ComponentRendererComponent --|> OnInit\n *   ComponentRendererComponent --|> OnChanges\n *   ComponentRendererComponent --|> OnDestroy\n *\n * @implements {OnInit}\n * @implements {OnChanges}\n * @implements {OnDestroy}\n */\n@Component({\n  selector: 'ngx-decaf-component-renderer',\n  templateUrl: './component-renderer.component.html',\n  styleUrls: ['./component-renderer.component.scss'],\n  imports: [ForAngularModule],\n  standalone: true,\n})\nexport class ComponentRendererComponent\n  implements OnInit, OnDestroy {\n  /**\n   * @description Reference to the container where the dynamic component will be rendered.\n   * @summary This ViewContainerRef provides the container where the dynamically created\n   * component will be inserted into the DOM. It's marked as static to ensure it's available\n   * during the ngOnInit lifecycle hook when the component is created.\n   *\n   * @type {ViewContainerRef}\n   * @memberOf ComponentRendererComponent\n   */\n  @ViewChild('componentViewContainer', { static: true, read: ViewContainerRef })\n  vcr!: ViewContainerRef;\n\n  /**\n   * @description The tag name of the component to be dynamically rendered.\n   * @summary This input property specifies which component should be rendered by providing\n   * its registered tag name. The tag must correspond to a component that has been registered\n   * with the NgxRenderingEngine2. This is a required input as it determines which component\n   * to create.\n   *\n   * @type {string}\n   * @required\n   * @memberOf ComponentRendererComponent\n   */\n  @Input({ required: true })\n  tag!: string;\n\n  /**\n   * @description Global properties to pass to the rendered component.\n   * @summary This input property allows passing a set of properties to the dynamically\n   * rendered component. These properties will be mapped to the component's inputs if they\n   * match. Properties that don't match any input on the target component will be filtered out\n   * with a warning.\n   *\n   * @type {Record<string, unknown>}\n   * @default {}\n   * @memberOf ComponentRendererComponent\n   */\n  @Input()\n  globals: Record<string, unknown> = {};\n\n  /**\n   * @description Injector used for dependency injection in the dynamic component.\n   * @summary This injector is used when creating the dynamic component to provide it with\n   * access to the application's dependency injection system. It ensures that the dynamically\n   * created component can access the same services and dependencies as statically created\n   * components.\n   *\n   * @type {EnvironmentInjector}\n   * @memberOf ComponentRendererComponent\n   */\n  injector: EnvironmentInjector = inject(EnvironmentInjector);\n\n  /**\n   * @description Reference to the dynamically created component.\n   * @summary This property holds a reference to the ComponentRef of the dynamically created\n   * component. It's used to interact with the component instance, subscribe to its events,\n   * and properly destroy it when the renderer is destroyed.\n   *\n   * @type {ComponentRef<unknown>}\n   * @memberOf ComponentRendererComponent\n   */\n  component!: ComponentRef<unknown>;\n\n  /**\n   * @description Event emitter for events from the rendered component.\n   * @summary This output property emits events that originate from the dynamically rendered\n   * component. It allows the parent component to listen for and respond to events from the\n   * dynamic component, creating a communication channel between the parent and the dynamically\n   * rendered child.\n   *\n   * @type {EventEmitter<ModelRenderCustomEvent>}\n   * @memberOf ComponentRendererComponent\n   */\n  @Output()\n  listenEvent: EventEmitter<ModelRenderCustomEvent> =\n    new EventEmitter<ModelRenderCustomEvent>();\n\n  /**\n   * @description Logger instance for the component.\n   * @summary This property holds a Logger instance specific to this component.\n   * It's used to log information, warnings, and errors related to the component's\n   * operations, particularly useful for debugging and monitoring the dynamic\n   * component rendering process.\n   *\n   * @type {Logger}\n   * @memberOf ComponentRendererComponent\n   */\n  logger!: Logger;\n\n  @Input()\n  parent: undefined | KeyValue = undefined;\n\n\n  @ViewChild('inner', { read: TemplateRef, static: true })\n  inner?: TemplateRef<unknown>;\n\n  /**\n   * @description Creates an instance of ComponentRendererComponent.\n   * @summary Initializes a new ComponentRendererComponent. This component doesn't require\n   * any dependencies to be injected in its constructor as it uses the inject function to\n   * obtain the EnvironmentInjector.\n   *\n   * @memberOf ComponentRendererComponent\n   */\n  constructor() {\n    this.logger = getLogger(this);\n  }\n\n  /**\n   * @description Initializes the component after Angular first displays the data-bound properties.\n   * @summary Sets up the component by creating the dynamic component specified by the tag input.\n   * This method is called once when the component is initialized and triggers the dynamic\n   * component creation process with the provided tag name and global properties.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant C as ComponentRendererComponent\n   *   participant R as NgxRenderingEngine2\n   *\n   *   A->>C: ngOnInit()\n   *   C->>C: createComponent(tag, globals)\n   *   C->>R: components(tag)\n   *   R-->>C: Return component constructor\n   *   C->>C: Process component inputs\n   *   C->>C: Create component instance\n   *   C->>C: subscribeEvents()\n   *\n   * @return {void}\n   * @memberOf ComponentRendererComponent\n   */\n  ngOnInit(): void {\n    if (!this.parent) {\n      this.createComponent(this.tag, this.globals);\n    } else {\n      this.createParentComponent();\n    }\n  }\n\n  /**\n   * @description Cleans up resources when the component is destroyed.\n   * @summary Performs cleanup operations when the component is being destroyed by Angular.\n   * This includes unsubscribing from all event emitters of the dynamic component and\n   * destroying the rendering engine instance to prevent memory leaks.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant C as ComponentRendererComponent\n   *   participant R as NgxRenderingEngine2\n   *\n   *   A->>C: ngOnDestroy()\n   *   alt component exists\n   *     C->>C: unsubscribeEvents()\n   *     C->>R: destroy()\n   *   end\n   *\n   * @return {Promise<void>} A promise that resolves when cleanup is complete\n   * @memberOf ComponentRendererComponent\n   */\n  async ngOnDestroy(): Promise<void> {\n    if (this.component) {\n      this.unsubscribeEvents();\n      NgxRenderingEngine2.destroy();\n    }\n  }\n\n  /**\n   * @description Creates and renders a dynamic component.\n   * @summary This method handles the creation of a dynamic component based on the provided tag.\n   * It retrieves the component constructor from the rendering engine, processes its inputs,\n   * filters out unmapped properties, creates the component instance, and sets up event subscriptions.\n   *\n   * @param {string} tag - The tag name of the component to create\n   * @param {KeyValue} globals - Global properties to pass to the component\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as ComponentRendererComponent\n   *   participant R as NgxRenderingEngine2\n   *   participant V as ViewContainerRef\n   *\n   *   C->>R: components(tag)\n   *   R-->>C: Return component constructor\n   *   C->>C: reflectComponentType(component)\n   *   C->>C: Process input properties\n   *   C->>C: Filter unmapped properties\n   *   C->>V: clear()\n   *   C->>R: createComponent(component, props, metadata, vcr, injector, [])\n   *   R-->>C: Return component reference\n   *   C->>C: subscribeEvents()\n   *\n   * @private\n   * @memberOf ComponentRendererComponent\n   */\n  private createComponent(tag: string, globals: KeyValue = {}): void {\n    const component = NgxRenderingEngine2.components(tag)\n      ?.constructor as Type<unknown>;\n    const metadata = reflectComponentType(component);\n    const componentInputs = (metadata as ComponentMirror<unknown>).inputs;\n    const props = globals?.['item'];\n    delete props['tag'];\n    const inputKeys = Object.keys(props);\n    const unmappedKeys = [];\n\n    for (const input of inputKeys) {\n      if (!inputKeys.length) break;\n      const prop = componentInputs.find(\n        (item: { propName: string }) => item.propName === input,\n      );\n      if (!prop) {\n        delete props[input];\n        unmappedKeys.push(input);\n      }\n    }\n    if (unmappedKeys.length)\n      this.logger.info(`Unmapped input properties for component ${tag}: ${unmappedKeys.join(', ')}`);\n\n    this.vcr.clear();\n    this.component = NgxRenderingEngine2.createComponent(\n      component,\n      props,\n      metadata as ComponentMirror<unknown>,\n      this.vcr,\n      this.injector as Injector,\n      [],\n    );\n    this.subscribeEvents();\n  }\n\n  createParentComponent() {\n    const { component, inputs } = this.parent as KeyValue;\n    const metadata = reflectComponentType(component) as ComponentMirror<unknown>;\n    const template = this.vcr.createEmbeddedView(this.inner as TemplateRef<unknown>, this.injector).rootNodes;\n    this.component = NgxRenderingEngine2.createComponent(\n      component,\n      inputs,\n      metadata,\n      this.vcr,\n      this.injector,\n      template,\n    );\n    this.subscribeEvents();\n  }\n\n  /**\n   * @description Subscribes to events emitted by the dynamic component.\n   * @summary This method sets up subscriptions to all EventEmitter properties of the\n   * dynamically created component. When an event is emitted by the dynamic component,\n   * it is captured and re-emitted through the listenEvent output property with additional\n   * metadata about the event source.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as ComponentRendererComponent\n   *   participant D as Dynamic Component\n   *   participant P as Parent Component\n   *\n   *   C->>C: subscribeEvents()\n   *   C->>D: Get instance properties\n   *   loop For each property\n   *     C->>C: Check if property is EventEmitter\n   *     alt is EventEmitter\n   *       C->>D: Subscribe to event\n   *       D-->>C: Event emitted\n   *       C->>P: Re-emit event with metadata\n   *     end\n   *   end\n   *\n   * @private\n   * @return {void}\n   * @memberOf ComponentRendererComponent\n   */\n  private subscribeEvents(): void {\n    if (this.component) {\n      const instance = this.component?.instance as KeyValue;\n      const componentKeys = Object.keys(instance);\n      for (const key of componentKeys) {\n        const value = instance[key];\n        if (value instanceof EventEmitter)\n          (instance as KeyValue)[key].subscribe(\n            (event: Partial<BaseCustomEvent>) => {\n              this.listenEvent.emit({\n                name: key,\n                ...event,\n              } as ModelRenderCustomEvent);\n            },\n          );\n      }\n    }\n  }\n\n  /**\n   * @description Unsubscribes from all events of the dynamic component.\n   * @summary This method cleans up event subscriptions when the component is being destroyed.\n   * It iterates through all properties of the dynamic component instance and unsubscribes\n   * from any EventEmitter properties to prevent memory leaks and unexpected behavior after\n   * the component is destroyed.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as ComponentRendererComponent\n   *   participant D as Dynamic Component\n   *\n   *   C->>C: unsubscribeEvents()\n   *   C->>D: Get instance properties\n   *   loop For each property\n   *     C->>C: Check if property is EventEmitter\n   *     alt is EventEmitter\n   *       C->>D: Unsubscribe from event\n   *     end\n   *   end\n   *\n   * @private\n   * @return {void}\n   * @memberOf ComponentRendererComponent\n   */\n  private unsubscribeEvents(): void {\n    if (this.component) {\n      const instance = this.component?.instance as KeyValue;\n      const componentKeys = Object.keys(instance);\n      for (const key of componentKeys) {\n        const value = instance[key];\n        if (value instanceof EventEmitter) instance[key].unsubscribe();\n      }\n    }\n  }\n}\n","<ng-template #componentViewContainer></ng-template>\n\n<ng-template #inner>\n  @if(parent?.children?.length) {\n    @for(child of parent.children; track child) {\n        @if(!child.children?.length) {\n          <ng-container\n                *ngComponentOutlet=\"\n                  child.component;\n                  injector: child.injector;\n                  inputs: child.inputs;\n                  content:child.content;\n                \"\n          />\n        } @else {\n          <ngx-decaf-component-renderer [parent]=\"child\"> </ngx-decaf-component-renderer>\n        }\n     }\n  }\n</ng-template>\n\n\n"]}