@decaf-ts/for-angular 0.0.7 → 0.0.9

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

@@ -0,0 +1,540 @@
+import { Input, Component, Inject, ViewChild, ElementRef, Output, EventEmitter, } from '@angular/core';
+import { getInjectablesRegistry, getLocaleFromClassName, } from 'src/lib/helpers/utils';
+import { stringToBoolean } from 'src/lib/helpers/utils';
+import { Model } from '@decaf-ts/decorator-validation';
+import { InternalError, OperationKeys } from '@decaf-ts/db-decorators';
+import { BaseComponentProps } from './constants';
+import { NgxRenderingEngine2 } from './NgxRenderingEngine2';
+import { getLogger } from '../for-angular.module';
+import { Repository } from '@decaf-ts/core';
+import * as i0 from "@angular/core";
+/**
+ * @description Base component class that provides common functionality for all Decaf components.
+ * @summary The NgxBaseComponent serves as the foundation for all Decaf UI components, providing
+ * shared functionality for localization, element references, and styling. This abstract class
+ * implements common properties and methods that are used across the component library, ensuring
+ * consistent behavior and reducing code duplication. Components that extend this class inherit
+ * its capabilities for handling translations, accessing DOM elements, and applying custom styling.
+ *
+ * @template M - The model type that this component works with
+ * @param {string} instance - The component instance token used for identification
+ * @param {string} locale - The locale to be used for translations
+ * @param {StringOrBoolean} translatable - Whether the component should be translated
+ * @param {string} className - Additional CSS classes to apply to the component
+ * @param {"ios" | "md" | undefined} mode - Component platform style
+ *
+ * @component NgxBaseComponent
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'app-my-component',
+ *   templateUrl: './my-component.component.html',
+ *   styleUrls: ['./my-component.component.scss']
+ * })
+ * export class MyComponent extends NgxBaseComponent {
+ *   constructor(@Inject('instanceToken') instance: string) {
+ *     super(instance);
+ *   }
+ *
+ *   ngOnInit() {
+ *     this.initialize();
+ *     // Component-specific initialization
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant App as Application
+ *   participant Comp as Component
+ *   participant Base as NgxBaseComponent
+ *   participant Engine as NgxRenderingEngine2
+ *
+ *   App->>Comp: Create component
+ *   Comp->>Base: super(instance)
+ *   Base->>Base: Set componentName & componentLocale
+ *
+ *   App->>Comp: Set @Input properties
+ *   Comp->>Base: ngOnChanges(changes)
+ *
+ *   alt model changed
+ *     Base->>Base: getModel(model)
+ *     Base->>Engine: getDecorators(model, {})
+ *     Engine-->>Base: Return decorator metadata
+ *     Base->>Base: Configure mapper and item
+ *     Base->>Base: getLocale(translatable)
+ *   else locale/translatable changed
+ *     Base->>Base: getLocale(translatable)
+ *   end
+ *
+ *   App->>Comp: ngOnInit()
+ *   Comp->>Base: initialize()
+ *   Base->>Base: Set initialized flag
+ */
+export class NgxBaseComponent {
+    /**
+     * @description Creates an instance of NgxBaseComponent.
+     * @summary Initializes a new instance of the base component with the provided instance token.
+     * This constructor sets up the fundamental properties required by all Decaf components,
+     * including the component name, locale settings, and logging capabilities. The instance
+     * token is used for component identification and locale derivation.
+     *
+     * The constructor performs the following initialization steps:
+     * 1. Sets the componentName from the provided instance token
+     * 2. Derives the componentLocale from the class name using utility functions
+     * 3. Initializes the logger instance for the component
+     *
+     * @param {string} instance - The component instance token used for identification
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular
+     *   participant C as Component
+     *   participant B as NgxBaseComponent
+     *   participant U as Utils
+     *   participant L as Logger
+     *
+     *   A->>C: new Component(instance)
+     *   C->>B: super(instance)
+     *   B->>B: Set componentName = instance
+     *   B->>U: getLocaleFromClassName(instance)
+     *   U-->>B: Return derived locale
+     *   B->>B: Set componentLocale
+     *   B->>L: getLogger(this)
+     *   L-->>B: Return logger instance
+     *   B->>B: Set logger
+     *
+     * @memberOf NgxBaseComponent
+     */
+    // eslint-disable-next-line @angular-eslint/prefer-inject
+    constructor(instance) {
+        this.instance = instance;
+        /**
+         * @description Dynamic properties configuration object.
+         * @summary Contains key-value pairs of dynamic properties that can be applied to the component
+         * at runtime. This flexible configuration object allows for dynamic property assignment without
+         * requiring explicit input bindings for every possible configuration option. Properties from
+         * this object are parsed and applied to the component instance through the parseProps method,
+         * enabling customizable component behavior based on external configuration.
+         *
+         * @type {Record<string, unknown>}
+         * @default {}
+         * @memberOf NgxBaseComponent
+         */
+        this.props = {};
+        /**
+         * @description Configuration for list item rendering
+         * @summary Defines how list items should be rendered in the component.
+         * This property holds a configuration object that specifies the tag name
+         * and other properties needed to render list items correctly. The tag property
+         * identifies which component should be used to render each item in a list.
+         * Additional properties can be included to customize the rendering behavior.
+         *
+         * @type {Record<string, unknown>}
+         * @default {tag: ""}
+         * @memberOf NgxBaseComponent
+         */
+        this.item = { tag: '' };
+        /**
+         * @description Primary key field name for the model.
+         * @summary Specifies which field in the model should be used as the primary key.
+         * This is typically used for identifying unique records in operations like update and delete.
+         *
+         * @type {string}
+         * @default 'id'
+         * @memberOf NgxBaseComponent
+         */
+        this.pk = 'id';
+        /**
+         * @description Available CRUD operations for this component.
+         * @summary Defines which CRUD operations (Create, Read, Update, Delete) are available
+         * for this component. This affects which operations can be performed on the data.
+         *
+         * @default [OperationKeys.READ]
+         * @memberOf NgxBaseComponent
+         */
+        this.operations = [OperationKeys.READ];
+        /**
+         * @description Field mapping configuration.
+         * @summary Defines how fields from the data model should be mapped to properties used by the component.
+         * This allows for flexible data binding between the model and the component's display logic.
+         *
+         * @type {Record<string, string>}
+         * @memberOf NgxBaseComponent
+         */
+        this.mapper = {};
+        /**
+         * @description Determines if the component should be translated.
+         * @summary Controls whether the component's text content should be processed for translation.
+         * When true, the component will attempt to translate text using the specified locale.
+         * When false, text is displayed as-is without translation. This property accepts either
+         * a boolean value or a string that can be converted to a boolean (e.g., 'true', 'false', '1', '0').
+         *
+         * @type {StringOrBoolean}
+         * @default false
+         * @memberOf NgxBaseComponent
+         */
+        this.translatable = true;
+        /**
+         * @description Additional CSS class names to apply to the component.
+         * @summary Allows custom CSS classes to be added to the component's root element.
+         * These classes are appended to any automatically generated classes based on other
+         * component properties. Multiple classes can be provided as a space-separated string.
+         * This provides a way to customize the component's appearance beyond the built-in styling options.
+         *
+         * @type {string}
+         * @default ""
+         * @memberOf NgxBaseComponent
+         */
+        this.className = '';
+        /**
+         * @description Component platform style.
+         * @summary Controls the visual appearance of the component based on platform design guidelines.
+         * The 'ios' mode follows iOS design patterns, while 'md' (Material Design) follows Android/Google
+         * design patterns. This property affects various visual aspects such as animations, form elements,
+         * and icons. Setting this property allows components to maintain platform-specific styling
+         * for a more native look and feel.
+         *
+         * @type {("ios" | "md" | undefined)}
+         * @default "md"
+         * @memberOf NgxBaseComponent
+         */
+        this.mode = 'md';
+        /**
+         * @description Controls whether child components should be rendered
+         * @summary Determines if child components should be rendered by the component.
+         * This can be set to a boolean value or a string that can be converted to a boolean.
+         * When true, child components defined in the model will be rendered. When false,
+         * child components will be skipped. This provides control over the rendering depth.
+         *
+         * @type {string | StringOrBoolean}
+         * @default true
+         * @memberOf NgxBaseComponent
+         */
+        this.renderChild = true;
+        /**
+         * @description Flag indicating if the component has been initialized
+         * @summary Tracks whether the component has completed its initialization process.
+         * This flag is used to prevent duplicate initialization and to determine if
+         * certain operations that require initialization can be performed.
+         *
+         * @type {boolean}
+         * @default false
+         */
+        this.initialized = false;
+        /**
+         * @description Event emitter for custom renderer events.
+         * @summary Emits custom events that occur within child components or the layout itself.
+         * This allows parent components to listen for and respond to user interactions or
+         * state changes within the grid layout. Events are passed up the component hierarchy
+         * to enable coordinated behavior across the application.
+         *
+         * @type {EventEmitter<RendererCustomEvent>}
+         * @memberOf NgxBaseComponent
+         */
+        this.listenEvent = new EventEmitter();
+        /**
+         * @description Reference to the rendering engine instance
+         * @summary Provides access to the NgxRenderingEngine2 singleton instance,
+         * which handles the rendering of components based on model definitions.
+         * This engine is used to extract decorator metadata and render child components.
+         *
+         * @type {NgxRenderingEngine2}
+         */
+        this.renderingEngine = NgxRenderingEngine2.get();
+        this.componentName = instance;
+        this.componentLocale = getLocaleFromClassName(instance);
+        this.logger = getLogger(this);
+        this.getLocale(this.translatable);
+    }
+    /**
+     * @description Getter for the repository instance.
+     * @summary Provides a connection to the data layer for retrieving and manipulating data.
+     * This method initializes the `_repository` property if it is not already set, ensuring
+     * that a single instance of the repository is used throughout the component.
+     *
+     * The repository is used to perform CRUD operations on the data model, such as fetching data,
+     * creating new items, updating existing items, and deleting items. It also provides methods
+     * for querying and filtering data based on specific criteria.
+     *
+     * @returns {DecafRepository<Model>} The initialized repository instance.
+     * @private
+     * @memberOf NgxBaseComponent
+     */
+    get repository() {
+        try {
+            if (!this._repository) {
+                const modelName = this.model.constructor.name;
+                const constructor = Model.get(modelName);
+                if (!constructor)
+                    throw new InternalError('Cannot find model. was it registered with @model?');
+                this._repository = Repository.forModel(constructor);
+                this.model = new constructor();
+            }
+        }
+        catch (error) {
+            throw new InternalError(error?.message || error);
+        }
+        return this._repository;
+    }
+    /**
+     * @description Parses and applies properties from the props object to the component instance.
+     * @summary This method iterates through the properties of the provided instance object
+     * and applies any matching properties from the component's props configuration to the
+     * component instance. This allows for dynamic property assignment based on configuration
+     * stored in the props object, enabling flexible component customization without requiring
+     * explicit property binding for every possible configuration option.
+     *
+     * The method performs a safe property assignment by checking if each key from the instance
+     * exists in the props object before applying it. This prevents accidental property
+     * overwriting and ensures only intended properties are modified.
+     *
+     * @param {KeyValue} instance - The component instance object to process
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant B as NgxBaseComponent
+     *   participant P as Props Object
+     *
+     *   C->>B: parseProps(instance)
+     *   B->>B: Get Object.keys(instance)
+     *   loop For each key in instance
+     *     B->>P: Check if key exists in this.props
+     *     alt Key exists in props
+     *       B->>B: Set this[key] = this.props[key]
+     *     else Key not in props
+     *       Note over B: Skip this key
+     *     end
+     *   end
+     *
+     * @protected
+     * @memberOf NgxBaseComponent
+     */
+    parseProps(instance) {
+        Object.keys(instance).forEach((key) => {
+            if (Object.keys(this.props).includes(key))
+                this[key] = this.props[key];
+        });
+    }
+    /**
+     * @description Handles changes to component inputs
+     * @summary This Angular lifecycle hook is called when input properties change.
+     * It responds to changes in the model, locale, or translatable properties by
+     * updating the component's internal state accordingly. When the model changes,
+     * it calls getModel to process the new model and getLocale to update the locale.
+     * When locale or translatable properties change, it calls getLocale to update
+     * the translation settings.
+     *
+     * @param {SimpleChanges} changes - Object containing changed properties
+     * @return {void}
+     */
+    ngOnChanges(changes) {
+        if (changes[BaseComponentProps.MODEL]) {
+            const { currentValue } = changes[BaseComponentProps.MODEL];
+            if (currentValue)
+                this.getModel(currentValue);
+            this.getLocale(this.translatable);
+        }
+        if (changes[BaseComponentProps.INITIALIZED] ||
+            changes[BaseComponentProps.LOCALE] ||
+            changes[BaseComponentProps.TRANSLATABLE])
+            this.getLocale(this.translatable);
+    }
+    /**
+     * @description Gets the appropriate locale string based on the translatable flag and available locales.
+     * @summary Determines which locale string to use for translation based on the translatable flag
+     * and available locale settings. This method first converts the translatable parameter to a boolean
+     * using the stringToBoolean utility function. If translatable is false, it returns an empty string,
+     * indicating no translation should be performed. If translatable is true, it checks for an explicitly
+     * provided locale via the locale property. If no explicit locale is available, it falls back to the
+     * componentLocale derived from the component's class name.
+     *
+     * @param {StringOrBoolean} translatable - Whether the component should be translated
+     * @return {string} The locale string to use for translation, or empty string if not translatable
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Component
+     *   participant N as NgxBaseComponent
+     *   participant S as StringUtils
+     *
+     *   C->>N: getLocale(translatable)
+     *   N->>S: stringToBoolean(translatable)
+     *   S-->>N: Return boolean value
+     *   N->>N: Store in this.translatable
+     *   alt translatable is false
+     *     N-->>C: Return empty string
+     *   else translatable is true
+     *     alt this.locale is defined
+     *       N-->>C: Return this.locale
+     *     else this.locale is not defined
+     *       N-->>C: Return this.componentLocale
+     *     end
+     *   end
+     */
+    getLocale(translatable) {
+        this.translatable = stringToBoolean(translatable);
+        if (!this.translatable)
+            return '';
+        if (!this.locale)
+            this.locale = this.componentLocale;
+        return this.locale;
+    }
+    /**
+     * @description Gets the route for the component
+     * @summary Retrieves the route path for the component, generating one based on the model
+     * if no route is explicitly set. This method checks if a route is already defined, and if not,
+     * it creates a default route based on the model's constructor name. The generated route follows
+     * the pattern '/model/{ModelName}'. This is useful for automatic routing in CRUD operations.
+     *
+     * @return {string} The route path for the component, or empty string if no route is available
+     */
+    getRoute() {
+        if (!this.route && this.model instanceof Model)
+            this.route = `/model/${this.model?.constructor.name}`;
+        return this.route || '';
+    }
+    /**
+     * @description Resolves and sets the component's model
+     * @summary Processes the provided model parameter, which can be either a Model instance
+     * or a string identifier. If a string is provided, it attempts to resolve the actual model
+     * from the injectables registry. After resolving the model, it calls setModelDefinitions
+     * to configure the component based on the model's metadata.
+     *
+     * @param {string | Model} model - The model instance or identifier string
+     * @return {void}
+     */
+    getModel(model) {
+        if (!(model instanceof Model))
+            this.model = getInjectablesRegistry().get(model);
+        this.setModelDefinitions(this.model);
+    }
+    /**
+     * @description Configures component properties based on model metadata
+     * @summary Extracts and applies configuration from the model's decorators to set up
+     * the component. This method uses the rendering engine to retrieve decorator metadata
+     * from the model, then configures the component's mapper and item properties accordingly.
+     * It ensures the route is properly set and merges various properties from the model's
+     * metadata into the component's configuration.
+     *
+     * @param {Model} model - The model to extract configuration from
+     * @return {void}
+     */
+    setModelDefinitions(model) {
+        if (model instanceof Model) {
+            this.getRoute();
+            this.model = model;
+            const field = this.renderingEngine.getDecorators(this.model, {});
+            const { props, item, children } = field;
+            this.props = Object.assign(props || {}, { children: children || [] });
+            if (item?.props?.['mapper'])
+                this.mapper = item?.props['mapper'] || {};
+            this.item = {
+                tag: item?.tag || '',
+                ...item?.props,
+                ...(this.mapper ? { mapper: this.mapper } : {}),
+                ...{ route: item?.props?.['route'] || this.route },
+            };
+        }
+    }
+    /**
+     * @description Initializes the component
+     * @summary Performs one-time initialization of the component. This method checks if
+     * the component has already been initialized to prevent duplicate initialization.
+     * When called for the first time, it sets the initialized flag to true and logs
+     * an initialization message with the component name. This method is typically called
+     * during the component's lifecycle setup.
+     */
+    initialize() {
+        this.initialized = true;
+    }
+    /**
+     * @description Handles custom events from child components.
+     * @summary Receives events from child renderer components and forwards them to parent
+     * components through the listenEvent output. This creates an event propagation chain
+     * that allows events to bubble up through the component hierarchy, enabling coordinated
+     * responses to user interactions across the layout structure.
+     *
+     * @param {RendererCustomEvent} event - The custom event from a child component
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Child Component
+     *   participant L as NgxBaseComponent
+     *   participant P as Parent Component
+     *
+     *   C->>L: Emit RendererCustomEvent
+     *   L->>L: handleEvent(event)
+     *   L->>P: listenEvent.emit(event)
+     *   Note over P: Handle event in parent
+     *
+     * @memberOf NgxBaseComponent
+     */
+    handleEvent(event) {
+        this.listenEvent.emit(event);
+    }
+    /**
+     * @description Tracks items in ngFor loops for optimal change detection.
+     * @summary Provides a tracking function for Angular's *ngFor directive to optimize rendering
+     * performance. This method generates unique identifiers for list items based on their index
+     * and content, allowing Angular to efficiently track changes and minimize DOM manipulations
+     * during list updates. The tracking function is essential for maintaining component state
+     * and preventing unnecessary re-rendering of unchanged items.
+     *
+     * @param {number} index - The index of the item in the list
+     * @param {KeyValue | string | number} item - The item data to track
+     * @returns {string | number} A unique identifier for the item
+     * @memberOf NgxBaseComponent
+     */
+    trackItemFn(index, item) {
+        return `${index}-${item}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NgxBaseComponent, deps: [{ token: 'instanceToken' }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: NgxBaseComponent, isStandalone: true, selector: "ng-component", inputs: { rendererId: "rendererId", model: "model", props: "props", item: "item", pk: "pk", route: "route", operations: "operations", uid: "uid", mapper: "mapper", locale: "locale", translatable: "translatable", className: "className", mode: "mode", renderChild: "renderChild" }, outputs: { listenEvent: "listenEvent" }, viewQueries: [{ propertyName: "component", first: true, predicate: ["component"], descendants: true, read: ElementRef, static: true }], usesOnChanges: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NgxBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['instanceToken']
+                }] }], propDecorators: { component: [{
+                type: ViewChild,
+                args: ['component', { read: ElementRef, static: true }]
+            }], rendererId: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], props: [{
+                type: Input
+            }], item: [{
+                type: Input
+            }], pk: [{
+                type: Input
+            }], route: [{
+                type: Input
+            }], operations: [{
+                type: Input
+            }], uid: [{
+                type: Input
+            }], mapper: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }], translatable: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], renderChild: [{
+                type: Input
+            }], listenEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxBaseComponent.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxBaseComponent.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Input,\n  Component,\n  Inject,\n  ViewChild,\n  ElementRef,\n  OnChanges,\n  SimpleChanges,\n  Output,\n  EventEmitter,\n} from '@angular/core';\nimport { KeyValue, RendererCustomEvent, StringOrBoolean } from 'src/lib/engine/types';\nimport {\n  getInjectablesRegistry,\n  getLocaleFromClassName,\n} from 'src/lib/helpers/utils';\nimport { stringToBoolean } from 'src/lib/helpers/utils';\nimport { Model } from '@decaf-ts/decorator-validation';\nimport {\n  CrudOperations,\n  InternalError,\n  OperationKeys\n} from '@decaf-ts/db-decorators';\nimport { BaseComponentProps } from './constants';\nimport { NgxRenderingEngine2 } from './NgxRenderingEngine2';\nimport { Logger } from '@decaf-ts/logging';\nimport { getLogger } from '../for-angular.module';\nimport { DecafRepository } from '../components/list/constants';\nimport { Repository } from '@decaf-ts/core';\n\n/**\n * @description Base component class that provides common functionality for all Decaf components.\n * @summary The NgxBaseComponent serves as the foundation for all Decaf UI components, providing\n * shared functionality for localization, element references, and styling. This abstract class\n * implements common properties and methods that are used across the component library, ensuring\n * consistent behavior and reducing code duplication. Components that extend this class inherit\n * its capabilities for handling translations, accessing DOM elements, and applying custom styling.\n *\n * @template M - The model type that this component works with\n * @param {string} instance - The component instance token used for identification\n * @param {string} locale - The locale to be used for translations\n * @param {StringOrBoolean} translatable - Whether the component should be translated\n * @param {string} className - Additional CSS classes to apply to the component\n * @param {\"ios\" | \"md\" | undefined} mode - Component platform style\n *\n * @component NgxBaseComponent\n * @example\n * ```typescript\n * @Component({\n *   selector: 'app-my-component',\n *   templateUrl: './my-component.component.html',\n *   styleUrls: ['./my-component.component.scss']\n * })\n * export class MyComponent extends NgxBaseComponent {\n *   constructor(@Inject('instanceToken') instance: string) {\n *     super(instance);\n *   }\n *\n *   ngOnInit() {\n *     this.initialize();\n *     // Component-specific initialization\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant App as Application\n *   participant Comp as Component\n *   participant Base as NgxBaseComponent\n *   participant Engine as NgxRenderingEngine2\n *\n *   App->>Comp: Create component\n *   Comp->>Base: super(instance)\n *   Base->>Base: Set componentName & componentLocale\n *\n *   App->>Comp: Set @Input properties\n *   Comp->>Base: ngOnChanges(changes)\n *\n *   alt model changed\n *     Base->>Base: getModel(model)\n *     Base->>Engine: getDecorators(model, {})\n *     Engine-->>Base: Return decorator metadata\n *     Base->>Base: Configure mapper and item\n *     Base->>Base: getLocale(translatable)\n *   else locale/translatable changed\n *     Base->>Base: getLocale(translatable)\n *   end\n *\n *   App->>Comp: ngOnInit()\n *   Comp->>Base: initialize()\n *   Base->>Base: Set initialized flag\n */\n@Component({\n  standalone: true,\n  template: '',\n})\nexport abstract class NgxBaseComponent implements OnChanges {\n  /**\n   * @description Reference to the component's element.\n   * @summary Provides direct access to the native DOM element of the component through Angular's\n   * ViewChild decorator. This reference can be used to manipulate the DOM element directly,\n   * apply custom styles, or access native element properties and methods. The element is\n   * identified by the 'component' template reference variable.\n   *\n   * @type {ElementRef}\n   * @memberOf NgxBaseComponent\n   */\n  @ViewChild('component', { read: ElementRef, static: true })\n  component!: ElementRef;\n\n  /**\n   * @description The name of the component.\n   * @summary Stores the name of the component, which is typically derived from the class name.\n   * This property is used internally for various purposes such as logging, deriving the default\n   * locale, and potentially for component identification in debugging or error reporting.\n   *\n   * The `componentName` is set during the component's initialization process and should not\n   * be modified externally. It's marked as protected to allow access in derived classes while\n   * preventing direct access from outside the component hierarchy.\n   *\n   * @type {string}\n   * @protected\n   * @memberOf NgxBaseComponent\n   *\n   * @example\n   * // Inside a derived component class\n   * console.log(this.componentName); // Outputs: \"MyCustomComponent\"\n   */\n  componentName!: string;\n\n  /**\n   * @description Unique identifier for the renderer.\n   * @summary A unique identifier used to reference the component's renderer instance.\n   * This can be used for targeting specific renderer instances when multiple components\n   * are present on the same page.\n   *\n   * @type {string}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  rendererId!: string;\n\n  /**\n   * @description Repository model for data operations.\n   * @summary The data model repository that this component will use for CRUD operations.\n   * This provides a connection to the data layer for retrieving and manipulating data.\n   *\n   * @type {Model| undefined}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  model!:  Model | undefined;\n\n  /**\n   * @description The repository for interacting with the data model.\n   * @summary Provides a connection to the data layer for retrieving and manipulating data.\n   * This is an instance of the `DecafRepository` class from the `@decaf-ts/core` package,\n   * which is initialized in the `repository` getter method.\n   *\n   * The repository is used to perform CRUD (Create, Read, Update, Delete) operations on the\n   * data model, such as fetching data, creating new items, updating existing items, and deleting\n   * items. It also provides methods for querying and filtering data based on specific criteria.\n   *\n   * @type {DecafRepository<Model>}\n   * @private\n   * @memberOf NgxBaseComponent\n   */\n  protected _repository?: DecafRepository<Model>;\n\n  /**\n   * @description Dynamic properties configuration object.\n   * @summary Contains key-value pairs of dynamic properties that can be applied to the component\n   * at runtime. This flexible configuration object allows for dynamic property assignment without\n   * requiring explicit input bindings for every possible configuration option. Properties from\n   * this object are parsed and applied to the component instance through the parseProps method,\n   * enabling customizable component behavior based on external configuration.\n   *\n   * @type {Record<string, unknown>}\n   * @default {}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  props: Record<string, unknown> = {};\n\n  /**\n   * @description Configuration for list item rendering\n   * @summary Defines how list items should be rendered in the component.\n   * This property holds a configuration object that specifies the tag name\n   * and other properties needed to render list items correctly. The tag property\n   * identifies which component should be used to render each item in a list.\n   * Additional properties can be included to customize the rendering behavior.\n   *\n   * @type {Record<string, unknown>}\n   * @default {tag: \"\"}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  item: Record<string, unknown> = { tag: '' };\n\n  /**\n   * @description Primary key field name for the model.\n   * @summary Specifies which field in the model should be used as the primary key.\n   * This is typically used for identifying unique records in operations like update and delete.\n   *\n   * @type {string}\n   * @default 'id'\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  pk: string = 'id';\n\n  /**\n   * @description Base route for navigation related to this component.\n   * @summary Defines the base route path used for navigation actions related to this component.\n   * This is often used as a prefix for constructing navigation URLs.\n   *\n   * @type {string}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  route!: string;\n\n  /**\n   * @description Available CRUD operations for this component.\n   * @summary Defines which CRUD operations (Create, Read, Update, Delete) are available\n   * for this component. This affects which operations can be performed on the data.\n   *\n   * @default [OperationKeys.READ]\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  operations: CrudOperations[] = [OperationKeys.READ];\n\n  /**\n   * @description Unique identifier for the current record.\n   * @summary A unique identifier for the current record being displayed or manipulated.\n   * This is typically used in conjunction with the primary key for operations on specific records.\n   *\n   * @type {string | number}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  uid!: string | number;\n\n  /**\n   * @description Field mapping configuration.\n   * @summary Defines how fields from the data model should be mapped to properties used by the component.\n   * This allows for flexible data binding between the model and the component's display logic.\n   *\n   * @type {Record<string, string>}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  mapper: Record<string, string> = {};\n\n  /**\n   * @description The locale to be used for translations.\n   * @summary Specifies the locale identifier to use when translating component text.\n   * This can be set explicitly via input property to override the automatically derived\n   * locale from the component name. The locale is typically a language code (e.g., 'en', 'fr')\n   * or a language-region code (e.g., 'en-US', 'fr-CA') that determines which translation\n   * set to use for the component's text content.\n   *\n   * @type {string}\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  locale!: string;\n\n  /**\n   * @description Determines if the component should be translated.\n   * @summary Controls whether the component's text content should be processed for translation.\n   * When true, the component will attempt to translate text using the specified locale.\n   * When false, text is displayed as-is without translation. This property accepts either\n   * a boolean value or a string that can be converted to a boolean (e.g., 'true', 'false', '1', '0').\n   *\n   * @type {StringOrBoolean}\n   * @default false\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  translatable: StringOrBoolean = true;\n\n  /**\n   * @description Additional CSS class names to apply to the component.\n   * @summary Allows custom CSS classes to be added to the component's root element.\n   * These classes are appended to any automatically generated classes based on other\n   * component properties. Multiple classes can be provided as a space-separated string.\n   * This provides a way to customize the component's appearance beyond the built-in styling options.\n   *\n   * @type {string}\n   * @default \"\"\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  className: string = '';\n\n  /**\n   * @description Component platform style.\n   * @summary Controls the visual appearance of the component based on platform design guidelines.\n   * The 'ios' mode follows iOS design patterns, while 'md' (Material Design) follows Android/Google\n   * design patterns. This property affects various visual aspects such as animations, form elements,\n   * and icons. Setting this property allows components to maintain platform-specific styling\n   * for a more native look and feel.\n   *\n   * @type {(\"ios\" | \"md\" | undefined)}\n   * @default \"md\"\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  mode: 'ios' | 'md' | undefined = 'md';\n\n  /**\n   * @description The locale derived from the component's class name.\n   * @summary Stores the automatically derived locale based on the component's class name.\n   * This is determined during component initialization and serves as a fallback when no\n   * explicit locale is provided via the locale input property. The derivation is handled\n   * by the getLocaleFromClassName utility function, which extracts a locale identifier\n   * from the component's class name.\n   *\n   * @type {string}\n   * @memberOf NgxBaseComponent\n   */\n  componentLocale!: string;\n\n  /**\n   * @description Controls whether child components should be rendered\n   * @summary Determines if child components should be rendered by the component.\n   * This can be set to a boolean value or a string that can be converted to a boolean.\n   * When true, child components defined in the model will be rendered. When false,\n   * child components will be skipped. This provides control over the rendering depth.\n   *\n   * @type {string | StringOrBoolean}\n   * @default true\n   * @memberOf NgxBaseComponent\n   */\n  @Input()\n  renderChild: string | StringOrBoolean = true;\n\n  /**\n   * @description Flag indicating if the component has been initialized\n   * @summary Tracks whether the component has completed its initialization process.\n   * This flag is used to prevent duplicate initialization and to determine if\n   * certain operations that require initialization can be performed.\n   *\n   * @type {boolean}\n   * @default false\n   */\n  initialized: boolean = false;\n\n  /**\n   * @description Event emitter for custom renderer events.\n   * @summary Emits custom events that occur within child components or the layout itself.\n   * This allows parent components to listen for and respond to user interactions or\n   * state changes within the grid layout. Events are passed up the component hierarchy\n   * to enable coordinated behavior across the application.\n   *\n   * @type {EventEmitter<RendererCustomEvent>}\n   * @memberOf NgxBaseComponent\n   */\n  @Output()\n  listenEvent: EventEmitter<RendererCustomEvent> = new EventEmitter<RendererCustomEvent>();\n\n  /**\n   * @description Reference to the rendering engine instance\n   * @summary Provides access to the NgxRenderingEngine2 singleton instance,\n   * which handles the rendering of components based on model definitions.\n   * This engine is used to extract decorator metadata and render child components.\n   *\n   * @type {NgxRenderingEngine2}\n   */\n  renderingEngine: NgxRenderingEngine2 =\n    NgxRenderingEngine2.get() as unknown as NgxRenderingEngine2;\n\n  /**\n   * @description Logger instance for the component.\n   * @summary Provides logging capabilities for the component, allowing for consistent\n   * and structured logging of information, warnings, and errors. This logger is initialized\n   * in the ngOnInit method using the getLogger function from the ForAngularModule.\n   *\n   * The logger is used throughout the component to record important events, debug information,\n   * and potential issues. It helps in monitoring the component's behavior, tracking the flow\n   * of operations, and facilitating easier debugging and maintenance.\n   *\n   * @type {Logger}\n   * @private\n   * @memberOf NgxBaseComponent\n   */\n  logger!: Logger;\n\n  /**\n   * @description Creates an instance of NgxBaseComponent.\n   * @summary Initializes a new instance of the base component with the provided instance token.\n   * This constructor sets up the fundamental properties required by all Decaf components,\n   * including the component name, locale settings, and logging capabilities. The instance\n   * token is used for component identification and locale derivation.\n   *\n   * The constructor performs the following initialization steps:\n   * 1. Sets the componentName from the provided instance token\n   * 2. Derives the componentLocale from the class name using utility functions\n   * 3. Initializes the logger instance for the component\n   *\n   * @param {string} instance - The component instance token used for identification\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular\n   *   participant C as Component\n   *   participant B as NgxBaseComponent\n   *   participant U as Utils\n   *   participant L as Logger\n   *\n   *   A->>C: new Component(instance)\n   *   C->>B: super(instance)\n   *   B->>B: Set componentName = instance\n   *   B->>U: getLocaleFromClassName(instance)\n   *   U-->>B: Return derived locale\n   *   B->>B: Set componentLocale\n   *   B->>L: getLogger(this)\n   *   L-->>B: Return logger instance\n   *   B->>B: Set logger\n   *\n   * @memberOf NgxBaseComponent\n   */\n  // eslint-disable-next-line @angular-eslint/prefer-inject\n  protected constructor(@Inject('instanceToken') protected instance: string) {\n    this.componentName = instance;\n    this.componentLocale = getLocaleFromClassName(instance);\n    this.logger = getLogger(this);\n    this.getLocale(this.translatable);\n  }\n\n  /**\n   * @description Getter for the repository instance.\n   * @summary Provides a connection to the data layer for retrieving and manipulating data.\n   * This method initializes the `_repository` property if it is not already set, ensuring\n   * that a single instance of the repository is used throughout the component.\n   *\n   * The repository is used to perform CRUD operations on the data model, such as fetching data,\n   * creating new items, updating existing items, and deleting items. It also provides methods\n   * for querying and filtering data based on specific criteria.\n   *\n   * @returns {DecafRepository<Model>} The initialized repository instance.\n   * @private\n   * @memberOf NgxBaseComponent\n   */\n  protected get repository(): DecafRepository<Model> {\n    try {\n      if (!this._repository) {\n        const modelName  = (this.model as Model).constructor.name\n        const constructor = Model.get(modelName);\n        if (!constructor)\n          throw new InternalError(\n            'Cannot find model. was it registered with @model?',\n          );\n        this._repository = Repository.forModel(constructor);\n        this.model = new constructor() as Model;\n      }\n    } catch (error: unknown) {\n      throw new InternalError(\n        (error as Error)?.message || error as string\n      );\n    }\n    return this._repository;\n  }\n\n  /**\n   * @description Parses and applies properties from the props object to the component instance.\n   * @summary This method iterates through the properties of the provided instance object\n   * and applies any matching properties from the component's props configuration to the\n   * component instance. This allows for dynamic property assignment based on configuration\n   * stored in the props object, enabling flexible component customization without requiring\n   * explicit property binding for every possible configuration option.\n   *\n   * The method performs a safe property assignment by checking if each key from the instance\n   * exists in the props object before applying it. This prevents accidental property\n   * overwriting and ensures only intended properties are modified.\n   *\n   * @param {KeyValue} instance - The component instance object to process\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant B as NgxBaseComponent\n   *   participant P as Props Object\n   *\n   *   C->>B: parseProps(instance)\n   *   B->>B: Get Object.keys(instance)\n   *   loop For each key in instance\n   *     B->>P: Check if key exists in this.props\n   *     alt Key exists in props\n   *       B->>B: Set this[key] = this.props[key]\n   *     else Key not in props\n   *       Note over B: Skip this key\n   *     end\n   *   end\n   *\n   * @protected\n   * @memberOf NgxBaseComponent\n   */\n  protected parseProps(instance: KeyValue): void {\n    Object.keys(instance).forEach((key) => {\n      if(Object.keys(this.props).includes(key))\n        (this as KeyValue)[key] = this.props[key];\n    })\n  }\n\n  /**\n   * @description Handles changes to component inputs\n   * @summary This Angular lifecycle hook is called when input properties change.\n   * It responds to changes in the model, locale, or translatable properties by\n   * updating the component's internal state accordingly. When the model changes,\n   * it calls getModel to process the new model and getLocale to update the locale.\n   * When locale or translatable properties change, it calls getLocale to update\n   * the translation settings.\n   *\n   * @param {SimpleChanges} changes - Object containing changed properties\n   * @return {void}\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[BaseComponentProps.MODEL]) {\n      const { currentValue } = changes[BaseComponentProps.MODEL];\n      if (currentValue) this.getModel(currentValue);\n      this.getLocale(this.translatable);\n    }\n    if (\n      changes[BaseComponentProps.INITIALIZED] ||\n      changes[BaseComponentProps.LOCALE] ||\n      changes[BaseComponentProps.TRANSLATABLE]\n    )\n      this.getLocale(this.translatable);\n  }\n\n  /**\n   * @description Gets the appropriate locale string based on the translatable flag and available locales.\n   * @summary Determines which locale string to use for translation based on the translatable flag\n   * and available locale settings. This method first converts the translatable parameter to a boolean\n   * using the stringToBoolean utility function. If translatable is false, it returns an empty string,\n   * indicating no translation should be performed. If translatable is true, it checks for an explicitly\n   * provided locale via the locale property. If no explicit locale is available, it falls back to the\n   * componentLocale derived from the component's class name.\n   *\n   * @param {StringOrBoolean} translatable - Whether the component should be translated\n   * @return {string} The locale string to use for translation, or empty string if not translatable\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Component\n   *   participant N as NgxBaseComponent\n   *   participant S as StringUtils\n   *\n   *   C->>N: getLocale(translatable)\n   *   N->>S: stringToBoolean(translatable)\n   *   S-->>N: Return boolean value\n   *   N->>N: Store in this.translatable\n   *   alt translatable is false\n   *     N-->>C: Return empty string\n   *   else translatable is true\n   *     alt this.locale is defined\n   *       N-->>C: Return this.locale\n   *     else this.locale is not defined\n   *       N-->>C: Return this.componentLocale\n   *     end\n   *   end\n   */\n  getLocale(translatable: StringOrBoolean): string {\n    this.translatable = stringToBoolean(translatable);\n    if (!this.translatable)\n      return '';\n    if (!this.locale)\n      this.locale = this.componentLocale;\n    return this.locale;\n  }\n\n  /**\n   * @description Gets the route for the component\n   * @summary Retrieves the route path for the component, generating one based on the model\n   * if no route is explicitly set. This method checks if a route is already defined, and if not,\n   * it creates a default route based on the model's constructor name. The generated route follows\n   * the pattern '/model/{ModelName}'. This is useful for automatic routing in CRUD operations.\n   *\n   * @return {string} The route path for the component, or empty string if no route is available\n   */\n  getRoute(): string {\n    if (!this.route && this.model instanceof Model)\n      this.route = `/model/${this.model?.constructor.name}`;\n    return this.route || '';\n  }\n\n  /**\n   * @description Resolves and sets the component's model\n   * @summary Processes the provided model parameter, which can be either a Model instance\n   * or a string identifier. If a string is provided, it attempts to resolve the actual model\n   * from the injectables registry. After resolving the model, it calls setModelDefinitions\n   * to configure the component based on the model's metadata.\n   *\n   * @param {string | Model} model - The model instance or identifier string\n   * @return {void}\n   */\n  getModel(model: string | Model): void {\n    if (!(model instanceof Model))\n      this.model = getInjectablesRegistry().get(model) as Model;\n    this.setModelDefinitions(this.model as Model);\n  }\n\n  /**\n   * @description Configures component properties based on model metadata\n   * @summary Extracts and applies configuration from the model's decorators to set up\n   * the component. This method uses the rendering engine to retrieve decorator metadata\n   * from the model, then configures the component's mapper and item properties accordingly.\n   * It ensures the route is properly set and merges various properties from the model's\n   * metadata into the component's configuration.\n   *\n   * @param {Model} model - The model to extract configuration from\n   * @return {void}\n   */\n  setModelDefinitions(model: Model): void {\n    if (model instanceof Model) {\n      this.getRoute();\n      this.model = model;\n      const field = this.renderingEngine.getDecorators(this.model as Model, {});\n      const{ props, item, children } = field;\n      this.props = Object.assign(props || {}, {children: children || []});\n      if(item?.props?.['mapper'])\n        this.mapper = item?.props!['mapper'] || {};\n      this.item = {\n        tag: item?.tag || '',\n        ...item?.props,\n        ...(this.mapper ? {mapper: this.mapper} : {}),\n        ...{ route: item?.props?.['route'] || this.route },\n      };\n    }\n  }\n\n  /**\n   * @description Initializes the component\n   * @summary Performs one-time initialization of the component. This method checks if\n   * the component has already been initialized to prevent duplicate initialization.\n   * When called for the first time, it sets the initialized flag to true and logs\n   * an initialization message with the component name. This method is typically called\n   * during the component's lifecycle setup.\n   */\n  initialize(): void {\n    this.initialized = true;\n  }\n\n  /**\n   * @description Handles custom events from child components.\n   * @summary Receives events from child renderer components and forwards them to parent\n   * components through the listenEvent output. This creates an event propagation chain\n   * that allows events to bubble up through the component hierarchy, enabling coordinated\n   * responses to user interactions across the layout structure.\n   *\n   * @param {RendererCustomEvent} event - The custom event from a child component\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Child Component\n   *   participant L as NgxBaseComponent\n   *   participant P as Parent Component\n   *\n   *   C->>L: Emit RendererCustomEvent\n   *   L->>L: handleEvent(event)\n   *   L->>P: listenEvent.emit(event)\n   *   Note over P: Handle event in parent\n   *\n   * @memberOf NgxBaseComponent\n   */\n  handleEvent(event: RendererCustomEvent): void {\n    this.listenEvent.emit(event);\n  }\n\n  /**\n   * @description Tracks items in ngFor loops for optimal change detection.\n   * @summary Provides a tracking function for Angular's *ngFor directive to optimize rendering\n   * performance. This method generates unique identifiers for list items based on their index\n   * and content, allowing Angular to efficiently track changes and minimize DOM manipulations\n   * during list updates. The tracking function is essential for maintaining component state\n   * and preventing unnecessary re-rendering of unchanged items.\n   *\n   * @param {number} index - The index of the item in the list\n   * @param {KeyValue | string | number} item - The item data to track\n   * @returns {string | number} A unique identifier for the item\n   * @memberOf NgxBaseComponent\n   */\n  trackItemFn(index: number, item: KeyValue | string | number): string | number {\n    return `${index}-${item}`;\n  }\n}\n"]}