@decaf-ts/ui-decorators 0.5.9 → 0.5.10

package/lib/esm/model/model.d.ts

@@ -7,109 +7,215 @@ declare module "@decaf-ts/decorator-validation" {
         hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;
         hasErrors(previousVersion?: Model | any, ...exclusions: any[]): ModelErrorDefinition | undefined;
         /**
-         * @summary Compare object equality recursively
-         * @param {any} obj object to compare to
-         * @param {string} [exceptions] property names to be excluded from the comparison
+         * @description Compares this model with another object for equality
+         * @summary Compare object equality recursively, checking all properties
+         * @param {any} obj - Object to compare to
+         * @param {...string} exceptions - Property names to be excluded from the comparison
+         * @return {boolean} True if objects are equal, false otherwise
          */
         equals(obj: any, ...exceptions: string[]): boolean;
         /**
+         * @description Converts the model to a serialized string representation
          * @summary Returns the serialized model according to the currently defined {@link Serializer}
+         * @return {string} Serialized representation of the model
          */
         serialize(): string;
         /**
-         * @summary Override the implementation for js's 'toString()' which sucks...
+         * @description Provides a string representation of the model
+         * @summary Override the implementation for JavaScript's default toString() method
+         * @return {string} String representation of the model
          * @override
          */
         toString(): string;
         /**
-         * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+         * @description Generates a hash code for the model
+         * @summary Defines a default implementation for object hash based on Java's string hash algorithm
+         * @return {string} Hash code for the model
          */
         hash(): string;
         /**
-         * @summary Deserializes a Model
-         * @param {string} str
-         *
-         * @param args
+         * @description Converts a serialized string back to a model instance
+         * @summary Deserializes a Model from its string representation
+         * @param {string} str - The serialized string to deserialize
+         * @return {any} The deserialized model instance
          * @throws {Error} If it fails to parse the string, or if it fails to build the model
          */
         static deserialize(str: string): any;
         /**
-         * @summary Repopulates the Object properties with the ones from the new object
          * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
+         * @summary Repopulates the Object properties with the ones from the new object
+         * @template T - Type extending Model
+         * @param {T} self - The target model instance to update
+         * @param {T|Record<string, any>} [obj] - The source object to copy properties from
+         * @return {T} The updated model instance
          */
         static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
         /**
-         * @summary Repopulates the instance with the ones from the new Model Object
-         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-         * Is aware of nested Model Objects and rebuilds them also.
-         * When List properties are decorated with {@link list}, they list items will also be rebuilt
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
+         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self. Is aware of nested Model Objects and rebuilds them also. When List properties are decorated with {@link list}, the list items will also be rebuilt
+         * @summary Repopulates the instance with properties from the new Model Object, handling nested models
+         * @template T - Type extending Model
+         * @param {T} self - The target model instance to update
+         * @param {T|Record<string, any>} [obj] - The source model or object to copy properties from
+         * @return {T} The updated model instance
          */
         static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
         /**
-         * @summary Sets the Global {@link ModelBuilderFunction}
-         * @param {ModelBuilderFunction} [builder]
+         * @description Configures the global model builder function used for creating model instances
+         * @summary Sets the Global {@link ModelBuilderFunction} used for model construction
+         * @param {ModelBuilderFunction} [builder] - The builder function to set, or undefined to reset
+         * @return {void}
          */
         static setBuilder(builder?: ModelBuilderFunction): void;
         /**
-         * @summary Retrieves the current global {@link ModelBuilderFunction}
+         * @description Returns the currently configured global model builder function
+         * @summary Retrieves the current global {@link ModelBuilderFunction} used for model construction
+         * @return {ModelBuilderFunction|undefined} The current builder function or undefined if not set
          */
         static getBuilder(): ModelBuilderFunction | undefined;
         /**
-         * Returns the current {@link ModelRegistryManager}
-         *
-         * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+         * @description Retrieves the current model registry instance
+         * @summary Returns the current {@link ModelRegistryManager} used for model registration
+         * @return {BuilderRegistry<any>} ModelRegistry instance, defaults to {@link ModelRegistryManager}
+         * @private
          */
         private static getRegistry;
         /**
-         * Returns the current actingModelRegistry
-         *
-         * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+         * @description Sets the model registry to be used for model registration and retrieval
+         * @summary Configures the current model registry implementation
+         * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use
+         * @return {void}
          */
         static setRegistry(modelRegistry: BuilderRegistry<any>): void;
         /**
-         * @summary register new Models
-         * @param {any} constructor
-         * @param {string} [name] when not defined, the name of the constructor will be used
-         *
+         * @description Registers a model constructor with the model registry
+         * @summary Registers new Models for later retrieval and instantiation
+         * @template T - Type extending Model
+         * @param {ModelConstructor<T>} constructor - The model constructor to register
+         * @param {string} [name] - Optional name for registration, defaults to constructor name
+         * @return {void}
          * @see ModelRegistry
          */
         static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
         /**
-         * @summary Gets a registered Model {@link ModelConstructor}
-         * @param {string} name
-         *
+         * @description Retrieves a previously registered model constructor by name
+         * @summary Gets a registered Model {@link ModelConstructor} from the registry
+         * @template T - Type extending Model
+         * @param {string} name - The name of the model to retrieve
+         * @return {ModelConstructor<T>|undefined} The model constructor or undefined if not found
          * @see ModelRegistry
          */
         static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
         /**
-         * @param {Record<string, any>} obj
-         * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-         *
-         * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-         *
+         * @description Creates a new model instance from a plain object
+         * @summary Builds a model instance using the registered constructor
+         * @template T - Type extending Model
+         * @param {Record<string, any>} [obj] - The source object to build from
+         * @param {string} [clazz] - Optional class name to find the matching constructor
+         * @return {T} The built model instance
+         * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
          * @see ModelRegistry
          */
         static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+        /**
+         * @description Retrieves metadata associated with a model instance
+         * @summary Gets the metadata attached to a model
+         * @template V - Type extending Model
+         * @param {V} model - The model instance to get metadata from
+         * @return {any} The model's metadata
+         */
         static getMetadata<V extends Model>(model: V): any;
+        /**
+         * @description Retrieves all attribute names defined on a model
+         * @summary Gets the list of attributes for a model class or instance
+         * @template V - Type extending Model
+         * @param {(Constructor<V>|V)} model - The model constructor or instance
+         * @return {string[]} Array of attribute names
+         */
         static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
-        static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]): boolean;
-        static hasErrors<V extends Model>(model: V, ...exceptions: any[]): ModelErrorDefinition | undefined;
-        static serialize<V extends Model>(model: V): any;
-        static hash<V extends Model>(model: V): any;
         /**
-         * @summary Builds the key to store as Metadata under Reflections
-         * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-         * @param {string} str
+         * @description Compares two model instances for equality
+         * @summary Static method to check if two model instances are equal
+         * @template M - Type extending Model
+         * @param {M} obj1 - First model instance to compare
+         * @param {M} obj2 - Second model instance to compare
+         * @param {any[]} exceptions - Properties to exclude from comparison
+         * @return {boolean} True if models are equal, false otherwise
+         */
+        static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]): boolean;
+        /**
+         * @description Validates a model and checks for errors
+         * @summary Static method to validate a model instance
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to validate
+         * @param {string[]} propsToIgnore - Properties to exclude from validation
+         * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
+         */
+        static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+        /**
+         * @description Serializes a model instance to a string
+         * @summary Static method to convert a model to its serialized form
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to serialize
+         * @return {string} The serialized representation of the model
+         */
+        static serialize<M extends Model>(model: M): any;
+        /**
+         * @description Generates a hash code for a model instance
+         * @summary Static method to create a hash code for a model
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to hash
+         * @return {string} The hash code for the model
+         */
+        static hash<M extends Model>(model: M): any;
+        /**
+         * @description Builds a metadata key for reflection
+         * @summary Concatenates the model reflection prefix with the provided key string
+         * @param {string} str - The key string to append to the reflection prefix
+         * @return {string} The complete metadata key
          */
         static key(str: string): string;
+        /**
+         * @description Determines if an object is a model instance or has model metadata
+         * @summary Checks whether a given object is either an instance of the Model class or
+         * has model metadata attached to it. This function is essential for serialization and
+         * deserialization processes, as it helps identify model objects that need special handling.
+         * It safely handles potential errors during metadata retrieval.
+         *
+         * @param {Record<string, any>} target - The object to check
+         * @return {boolean} True if the object is a model instance or has model metadata, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if an object is a model
+         * const user = new User({ name: "John" });
+         * const isUserModel = isModel(user); // true
+         *
+         * // Check a plain object
+         * const plainObject = { name: "John" };
+         * const isPlainObjectModel = isModel(plainObject); // false
+         * ```
+         */
+        static isModel(target: Record<string, any>): boolean;
+        /**
+         * @description Checks if a property of a model is itself a model or has a model type
+         * @summary Determines whether a specific property of a model instance is either a model instance
+         * or has a type that is registered as a model. This function is used for model serialization
+         * and deserialization to properly handle nested models.
+         * @template M extends {@link Model}
+         * @param {M} target - The model instance to check
+         * @param {string} attribute - The property name to check
+         * @return {boolean | string | undefined} Returns true if the property is a model instance,
+         * the model name if the property has a model type, or undefined if not a model
+         */
+        static isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
+        /**
+         * @description Checks if a property of a model is itself a model or has a model type
+         * @summary Determines whether a specific property of a model instance is either a model instance
+         * or has a type that is registered as a model. This function is used for model serialization
+         * and deserialization to properly handle nested models.
+         * @template R the expected UI code according to each rendering engine
+         * @param {any[]} args - optional engine specific args
+         */
         render<R>(...args: any[]): R;
     }
 }

package/lib/esm/model/model.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/model/model.ts"],"names":[],"mappings":"","sourcesContent":["import { ModelErrorDefinition } from \"@decaf-ts/decorator-validation\";\nimport {\n  BuilderRegistry,\n  Comparable,\n  Constructor,\n  Hashable,\n  ModelArg,\n  ModelBuilderFunction,\n  ModelConstructor,\n  Serializable,\n  Validatable,\n} from \"@decaf-ts/decorator-validation\";\nimport { Renderable } from \"./Renderable\";\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-expect-error\n  declare abstract class Model\n    implements\n      Validatable,\n      Serializable,\n      Hashable,\n      Comparable<Model>,\n      Renderable\n  {\n    protected constructor(arg?: ModelArg<Model>);\n\n    hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;\n    hasErrors(\n      previousVersion?: Model | any,\n      ...exclusions: any[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @description Compares this model with another object for equality\n     * @summary Compare object equality recursively, checking all properties\n     * @param {any} obj - Object to compare to\n     * @param {...string} exceptions - Property names to be excluded from the comparison\n     * @return {boolean} True if objects are equal, false otherwise\n     */\n    equals(obj: any, ...exceptions: string[]): boolean;\n\n    /**\n     * @description Converts the model to a serialized string representation\n     * @summary Returns the serialized model according to the currently defined {@link Serializer}\n     * @return {string} Serialized representation of the model\n     */\n    serialize(): string;\n\n    /**\n     * @description Provides a string representation of the model\n     * @summary Override the implementation for JavaScript's default toString() method\n     * @return {string} String representation of the model\n     * @override\n     */\n    toString(): string;\n\n    /**\n     * @description Generates a hash code for the model\n     * @summary Defines a default implementation for object hash based on Java's string hash algorithm\n     * @return {string} Hash code for the model\n     */\n    hash(): string;\n\n    /**\n     * @description Converts a serialized string back to a model instance\n     * @summary Deserializes a Model from its string representation\n     * @param {string} str - The serialized string to deserialize\n     * @return {any} The deserialized model instance\n     * @throws {Error} If it fails to parse the string, or if it fails to build the model\n     */\n    static deserialize(str: string): any;\n\n    /**\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n     * @summary Repopulates the Object properties with the ones from the new object\n     * @template T - Type extending Model\n     * @param {T} self - The target model instance to update\n     * @param {T|Record<string, any>} [obj] - The source object to copy properties from\n     * @return {T} The updated model instance\n     */\n    static fromObject<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self. Is aware of nested Model Objects and rebuilds them also. When List properties are decorated with {@link list}, the list items will also be rebuilt\n     * @summary Repopulates the instance with properties from the new Model Object, handling nested models\n     * @template T - Type extending Model\n     * @param {T} self - The target model instance to update\n     * @param {T|Record<string, any>} [obj] - The source model or object to copy properties from\n     * @return {T} The updated model instance\n     */\n    static fromModel<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @description Configures the global model builder function used for creating model instances\n     * @summary Sets the Global {@link ModelBuilderFunction} used for model construction\n     * @param {ModelBuilderFunction} [builder] - The builder function to set, or undefined to reset\n     * @return {void}\n     */\n    static setBuilder(builder?: ModelBuilderFunction): void;\n\n    /**\n     * @description Returns the currently configured global model builder function\n     * @summary Retrieves the current global {@link ModelBuilderFunction} used for model construction\n     * @return {ModelBuilderFunction|undefined} The current builder function or undefined if not set\n     */\n    static getBuilder(): ModelBuilderFunction | undefined;\n\n    /**\n     * @description Retrieves the current model registry instance\n     * @summary Returns the current {@link ModelRegistryManager} used for model registration\n     * @return {BuilderRegistry<any>} ModelRegistry instance, defaults to {@link ModelRegistryManager}\n     * @private\n     */\n    private static getRegistry;\n\n    /**\n     * @description Sets the model registry to be used for model registration and retrieval\n     * @summary Configures the current model registry implementation\n     * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use\n     * @return {void}\n     */\n    static setRegistry(modelRegistry: BuilderRegistry<any>): void;\n\n    /**\n     * @description Registers a model constructor with the model registry\n     * @summary Registers new Models for later retrieval and instantiation\n     * @template T - Type extending Model\n     * @param {ModelConstructor<T>} constructor - The model constructor to register\n     * @param {string} [name] - Optional name for registration, defaults to constructor name\n     * @return {void}\n     * @see ModelRegistry\n     */\n    static register<T extends Model>(\n      constructor: ModelConstructor<T>,\n      name?: string\n    ): void;\n\n    /**\n     * @description Retrieves a previously registered model constructor by name\n     * @summary Gets a registered Model {@link ModelConstructor} from the registry\n     * @template T - Type extending Model\n     * @param {string} name - The name of the model to retrieve\n     * @return {ModelConstructor<T>|undefined} The model constructor or undefined if not found\n     * @see ModelRegistry\n     */\n    static get<T extends Model>(name: string): ModelConstructor<T> | undefined;\n\n    /**\n     * @description Creates a new model instance from a plain object\n     * @summary Builds a model instance using the registered constructor\n     * @template T - Type extending Model\n     * @param {Record<string, any>} [obj] - The source object to build from\n     * @param {string} [clazz] - Optional class name to find the matching constructor\n     * @return {T} The built model instance\n     * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n     * @see ModelRegistry\n     */\n    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;\n\n    /**\n     * @description Retrieves metadata associated with a model instance\n     * @summary Gets the metadata attached to a model\n     * @template V - Type extending Model\n     * @param {V} model - The model instance to get metadata from\n     * @return {any} The model's metadata\n     */\n    static getMetadata<V extends Model>(model: V): any;\n\n    /**\n     * @description Retrieves all attribute names defined on a model\n     * @summary Gets the list of attributes for a model class or instance\n     * @template V - Type extending Model\n     * @param {(Constructor<V>|V)} model - The model constructor or instance\n     * @return {string[]} Array of attribute names\n     */\n    static getAttributes<V extends Model>(model: Constructor<V> | V): string[];\n\n    /**\n     * @description Compares two model instances for equality\n     * @summary Static method to check if two model instances are equal\n     * @template M - Type extending Model\n     * @param {M} obj1 - First model instance to compare\n     * @param {M} obj2 - Second model instance to compare\n     * @param {any[]} exceptions - Properties to exclude from comparison\n     * @return {boolean} True if models are equal, false otherwise\n     */\n    static equals<M extends Model>(\n      obj1: M,\n      obj2: M,\n      ...exceptions: any[]\n    ): boolean;\n\n    /**\n     * @description Validates a model and checks for errors\n     * @summary Static method to validate a model instance\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to validate\n     * @param {string[]} propsToIgnore - Properties to exclude from validation\n     * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise\n     */\n    static hasErrors<M extends Model>(\n      model: M,\n      ...propsToIgnore: string[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @description Serializes a model instance to a string\n     * @summary Static method to convert a model to its serialized form\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to serialize\n     * @return {string} The serialized representation of the model\n     */\n    static serialize<M extends Model>(model: M): any;\n\n    /**\n     * @description Generates a hash code for a model instance\n     * @summary Static method to create a hash code for a model\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to hash\n     * @return {string} The hash code for the model\n     */\n    static hash<M extends Model>(model: M): any;\n\n    /**\n     * @description Builds a metadata key for reflection\n     * @summary Concatenates the model reflection prefix with the provided key string\n     * @param {string} str - The key string to append to the reflection prefix\n     * @return {string} The complete metadata key\n     */\n    static key(str: string): string;\n\n    /**\n     * @description Determines if an object is a model instance or has model metadata\n     * @summary Checks whether a given object is either an instance of the Model class or\n     * has model metadata attached to it. This function is essential for serialization and\n     * deserialization processes, as it helps identify model objects that need special handling.\n     * It safely handles potential errors during metadata retrieval.\n     *\n     * @param {Record<string, any>} target - The object to check\n     * @return {boolean} True if the object is a model instance or has model metadata, false otherwise\n     *\n     * @example\n     * ```typescript\n     * // Check if an object is a model\n     * const user = new User({ name: \"John\" });\n     * const isUserModel = isModel(user); // true\n     *\n     * // Check a plain object\n     * const plainObject = { name: \"John\" };\n     * const isPlainObjectModel = isModel(plainObject); // false\n     * ```\n     */\n    static isModel(target: Record<string, any>): boolean;\n\n    /**\n     * @description Checks if a property of a model is itself a model or has a model type\n     * @summary Determines whether a specific property of a model instance is either a model instance\n     * or has a type that is registered as a model. This function is used for model serialization\n     * and deserialization to properly handle nested models.\n     * @template M extends {@link Model}\n     * @param {M} target - The model instance to check\n     * @param {string} attribute - The property name to check\n     * @return {boolean | string | undefined} Returns true if the property is a model instance,\n     * the model name if the property has a model type, or undefined if not a model\n     */\n    static isPropertyModel<M extends Model>(\n      target: M,\n      attribute: string\n    ): boolean | string | undefined;\n\n    /**\n     * @description Checks if a property of a model is itself a model or has a model type\n     * @summary Determines whether a specific property of a model instance is either a model instance\n     * or has a type that is registered as a model. This function is used for model serialization\n     * and deserialization to properly handle nested models.\n     * @template R the expected UI code according to each rendering engine\n     * @param {any[]} args - optional engine specific args\n     */\n    render<R>(...args: any[]): R;\n  }\n}\n"]}

package/lib/esm/model/overrides.d.ts

@@ -1 +1,9 @@
+/**
+ * @description Module that extends the Model prototype with rendering capabilities
+ * @summary Adds the render method to all Model instances from decorator-validation
+ * This module implements the Renderable interface for the Model class by adding a render method
+ * to its prototype. This allows any Model instance to be rendered using the RenderingEngine.
+ * @module model/overrides
+ * @memberOf module:ui-decorators/model
+ */
 export {};

package/lib/esm/model/overrides.js

@@ -1,6 +1,24 @@
+/**
+ * @description Module that extends the Model prototype with rendering capabilities
+ * @summary Adds the render method to all Model instances from decorator-validation
+ * This module implements the Renderable interface for the Model class by adding a render method
+ * to its prototype. This allows any Model instance to be rendered using the RenderingEngine.
+ * @module model/overrides
+ * @memberOf module:ui-decorators/model
+ */
 import { Model } from "@decaf-ts/decorator-validation";
 import { RenderingEngine } from "../ui/Rendering";
+/**
+ * @description Renders the model using the appropriate rendering engine
+ * @summary Delegates rendering to the RenderingEngine based on model metadata
+ * This method implements the render method from the Renderable interface for all Model instances.
+ * It uses the RenderingEngine to determine how to render the model based on its metadata.
+ *
+ * @template M Type of the model being rendered
+ * @param {any[]} args Additional arguments to pass to the rendering engine
+ * @return {any} The rendered output in the format determined by the rendering engine
+ */
 Model.prototype.render = function (...args) {
     return RenderingEngine.render(this, ...args);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcnJpZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsL292ZXJyaWRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWxELEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxHQUFHLFVBQW9DLEdBQUcsSUFBVztJQUN6RSxPQUFPLGVBQWUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7QUFDL0MsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBSZW5kZXJpbmdFbmdpbmUgfSBmcm9tIFwiLi4vdWkvUmVuZGVyaW5nXCI7XG5cbk1vZGVsLnByb3RvdHlwZS5yZW5kZXIgPSBmdW5jdGlvbiA8TSBleHRlbmRzIE1vZGVsPih0aGlzOiBNLCAuLi5hcmdzOiBhbnlbXSkge1xuICByZXR1cm4gUmVuZGVyaW5nRW5naW5lLnJlbmRlcih0aGlzLCAuLi5hcmdzKTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/ui/Rendering.js

@@ -156,6 +156,9 @@ export class RenderingEngine {
         let children;
         let childProps = item?.props || {};
         let mapper = {};
+        const getPath = (parent, prop) => {
+            return parent ? [parent, prop].join(".") : prop;
+        };
         if (uiDecorators) {
             const validationDecorators = Reflection.getAllPropertyDecorators(model, ValidationKeys.REFLECT);
             for (const key in uiDecorators) {
@@ -181,7 +184,10 @@ export class RenderingEngine {
                             if (!constructable)
                                 Clazz = new (Model.get(dec.props?.name))();
                             children = children || [];
-                            const childDefinition = this.toFieldDefinition(submodel || Clazz, globalProps, false);
+                            const childrenGlobalProps = Object.assign({}, globalProps || {}, {
+                                childOf: getPath(globalProps?.childOf, key),
+                            });
+                            const childDefinition = this.toFieldDefinition(submodel || Clazz, childrenGlobalProps, false);
                             children.push(childDefinition);
                             break;
                         }
@@ -197,9 +203,14 @@ export class RenderingEngine {
                         }
                         case UIKeys.ELEMENT: {
                             children = children || [];
+                            const uiProps = dec.props;
+                            const props = Object.assign({}, uiProps.props, {
+                                path: getPath(globalProps?.childOf, uiProps.props.name),
+                                childOf: undefined, // The childOf prop is passed by globalProps when it is a nested prop
+                            }, globalProps);
                             const childDefinition = {
-                                tag: dec.props.tag,
-                                props: Object.assign({}, dec.props.props, globalProps),
+                                tag: uiProps.tag,
+                                props,
                             };
                             const validationDecs = validationDecorators[key];
                             const typeDec = validationDecs.shift();
@@ -326,4 +337,4 @@ export class RenderingEngine {
         return `${UIKeys.REFLECT}${key}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Rendering.js","sourceRoot":"","sources":["../../../src/ui/Rendering.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalError } from \"@decaf-ts/db-decorators\";\nimport {\n  Constructor,\n  Model,\n  ModelConstructor,\n  ReservedModels,\n  ValidationKeys,\n  ValidationMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  HTML5DateFormat,\n  HTML5InputTypes,\n  UIKeys,\n  ValidatableByAttribute,\n  ValidatableByType,\n} from \"./constants\";\nimport {\n  FieldDefinition,\n  FieldProperties,\n  UIElementMetadata,\n  UIListItemElementMetadata,\n  UIListItemModelMetadata,\n  UIModelMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { RenderingError } from \"./errors\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { formatByType, generateUIModelID } from \"./utils\";\n\n/**\n * @description Abstract class for rendering UI components based on model metadata.\n * @summary The RenderingEngine class provides a framework for converting model metadata into UI field definitions.\n * It handles the translation of model properties to UI elements, applies validation rules, and manages different rendering flavors.\n * This class is designed to be extended by specific rendering implementations.\n *\n * @template T The type of the rendering result, defaults to void\n * @template R The type of the field definition, defaults to FieldDefinition<T>\n *\n * @param {string} flavour - The flavor of the rendering engine.\n *\n * @class RenderingEngine\n */\nexport abstract class RenderingEngine<T = void, R = FieldDefinition<T>> {\n  /**\n   * @description Cache for storing rendering engine instances or constructors.\n   * @private\n   * @static\n   */\n  private static cache: Record<\n    string,\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>\n  > = {};\n\n  /**\n   * @description The currently active rendering engine.\n   * @private\n   * @static\n   */\n  private static current:\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>;\n\n  /**\n   * Flag indicating whether the rendering engine has been initialized.\n   */\n  protected initialized: boolean = false;\n\n  protected constructor(readonly flavour: string) {\n    RenderingEngine.register(this);\n    console.log(`decaf's ${flavour} rendering engine loaded`);\n  }\n\n  /**\n   * @description Initializes the rendering engine.\n   * @summary Abstract method to be implemented by subclasses for specific initialization logic.\n   *\n   * @param {...any[]} args - Any additional arguments needed for initialization.\n   * @returns {Promise<void>} A promise that resolves when initialization is complete.\n   *\n   * @abstract\n   */\n  abstract initialize(...args: any[]): Promise<void>;\n\n  /**\n   * @description Translates between model types and HTML input types.\n   * @summary Converts model data types to appropriate HTML input types and vice versa.\n   *\n   * @param {string} key - The key to translate.\n   * @param {boolean} [toView=true] - Direction of translation (true for model to view, false for view to model).\n   * @returns {string} The translated type.\n   */\n  translate(key: string, toView: boolean = true): string {\n    if (toView) {\n      switch (key) {\n        case ReservedModels.STRING:\n          return HTML5InputTypes.TEXT;\n        case ReservedModels.NUMBER:\n        case ReservedModels.BIGINT:\n          return HTML5InputTypes.NUMBER;\n        case ReservedModels.BOOLEAN:\n          return HTML5InputTypes.CHECKBOX;\n        case ReservedModels.DATE:\n          return HTML5InputTypes.DATE;\n      }\n    } else {\n      switch (key) {\n        case HTML5InputTypes.TEXT:\n        case HTML5InputTypes.EMAIL:\n        case HTML5InputTypes.COLOR:\n        case HTML5InputTypes.PASSWORD:\n        case HTML5InputTypes.TEL:\n        case HTML5InputTypes.URL:\n          return ReservedModels.STRING;\n        case HTML5InputTypes.NUMBER:\n          return ReservedModels.NUMBER;\n        case HTML5InputTypes.CHECKBOX:\n          return ReservedModels.BOOLEAN;\n        case HTML5InputTypes.DATE:\n        case HTML5InputTypes.DATETIME_LOCAL:\n        case HTML5InputTypes.TIME:\n          return ReservedModels.DATE;\n      }\n    }\n    return key;\n  }\n\n  /**\n   * @description Checks if a type is validatable by its nature.\n   * @summary Determines if a given UI key represents a type that is inherently validatable.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable, false otherwise.\n   */\n  protected isValidatableByType(key: string): boolean {\n    return Object.keys(ValidatableByType).includes(key);\n  }\n\n  /**\n   * @description Checks if a type is validatable by attribute.\n   * @summary Determines if a given UI key represents a validation that can be applied as an attribute.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable by attribute, false otherwise.\n   */\n  protected isValidatableByAttribute(key: string): boolean {\n    return Object.keys(ValidatableByAttribute).includes(key);\n  }\n\n  /**\n   * @description Converts validation metadata to an attribute value.\n   * @summary Transforms validation metadata into a value suitable for use as an HTML attribute.\n   *\n   * @param {string} key - The validation key.\n   * @param {ValidationMetadata} value - The validation metadata.\n   * @returns {string | number | boolean} The converted attribute value.\n   * @throws {Error} If the given key is not validatable by attribute.\n   */\n  protected toAttributeValue(\n    key: string,\n    value: ValidationMetadata\n  ): string | number | boolean {\n    if (!Object.keys(ValidatableByAttribute).includes(key))\n      throw new Error(\n        `Invalid attribute key \"${key}\". Expected one of: ${Object.keys(ValidatableByAttribute).join(\", \")}.`\n      );\n\n    return key === UIKeys.REQUIRED ? true : value[key];\n  }\n\n  /**\n   * @description Converts a model to a field definition.\n   * @summary Processes a model instance, extracting UI-related metadata and validation rules to create a field definition.\n   *\n   * @template M Type extending Model\n   * @template T Type referencing the specific Rendering engine field properties/inputs\n   * @param {M} model - The model instance to convert.\n   * @param {Record<string, unknown>} [globalProps={}] - Global properties to apply to all child elements.\n   * @param {boolean} [generateId=true] - Flag indicating whether to populate the rendererId property.\n   * @returns {FieldDefinition<T>} A field definition object representing the UI structure of the model.\n   * @throws {RenderingError} If no UI definitions are set for the model or if there are invalid decorators.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *  participant C as Client\n   *  participant RE as RenderingEngine\n   *  participant R as Reflection\n   *  participant M as Model\n   *  C->>RE: toFieldDefinition(model, globalProps)\n   *  RE->>R: getMetadata(UIKeys.UIMODEL, model.constructor)\n   *  R-->>RE: UIModelMetadata\n   *  RE->>R: getAllPropertyDecorators(model, UIKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata[]>\n   *  RE->>R: getAllPropertyDecorators(model, ValidationKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata<ValidationMetadata>[]>\n   *  loop For each property\n   *    RE->>RE: Process UI decorators\n   *    RE->>RE: Apply validation rules\n   *  end\n   *  RE-->>C: FieldDefinition<T>\n   */\n  protected toFieldDefinition<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown> = {},\n    generateId: boolean = true\n  ): FieldDefinition<T> {\n    const classDecorators: [UIModelMetadata, UIListItemModelMetadata] = [\n      Reflect.getMetadata(\n        RenderingEngine.key(UIKeys.UIMODEL),\n        model.constructor\n      ) ||\n        Reflect.getMetadata(\n          RenderingEngine.key(UIKeys.UIMODEL),\n          Model.get(model.constructor.name) as any\n        ),\n      Reflect.getMetadata(\n        RenderingEngine.key(UIKeys.UILISTITEM),\n        model.constructor\n      ) ||\n        Reflect.getMetadata(\n          RenderingEngine.key(UIKeys.UILISTITEM),\n          Model.get(model.constructor.name) as any\n        ),\n    ];\n\n    if (!classDecorators)\n      throw new RenderingError(\n        `No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`\n      );\n\n    const classDecorator = Object.assign({}, ...classDecorators);\n    const { tag, props, item } = classDecorator;\n\n    const uiDecorators: Record<string, DecoratorMetadata[]> =\n      Reflection.getAllPropertyDecorators(model, UIKeys.REFLECT) as Record<\n        string,\n        DecoratorMetadata[]\n      >;\n    let children: FieldDefinition<Record<string, any>>[] | undefined;\n    let childProps: Record<string, any> = item?.props || {};\n    let mapper: Record<string, string> = {};\n\n    if (uiDecorators) {\n      const validationDecorators: Record<\n        string,\n        DecoratorMetadata<ValidationMetadata>[]\n      > = Reflection.getAllPropertyDecorators(\n        model,\n        ValidationKeys.REFLECT\n      ) as Record<string, DecoratorMetadata<ValidationMetadata>[]>;\n\n      for (const key in uiDecorators) {\n        const decs = uiDecorators[key];\n        const types = Object.values(decs).filter(\n          (item) => item.key === UIKeys.PROP || item.key === UIKeys.ELEMENT\n        );\n        if (types?.length > 1)\n          throw new RenderingError(\n            `Only one type of decoration is allowed. Please choose between @uiprop and @uielement`\n          );\n        decs.shift();\n        decs.forEach((dec) => {\n          if (!dec) throw new RenderingError(`No decorator found`);\n\n          switch (dec.key) {\n            case UIKeys.PROP: {\n              if (!Model.isPropertyModel(model, key)) {\n                childProps[key] = dec.props as UIPropMetadata;\n                break;\n              }\n\n              let Clazz;\n              const submodel = (model as Record<string, any>)[key] as Model;\n              const constructable =\n                typeof submodel === \"object\" &&\n                submodel !== null &&\n                !Array.isArray(submodel);\n              if (!constructable)\n                Clazz = new (Model.get(\n                  dec.props?.name as string\n                ) as ModelConstructor<Model>)();\n\n              children = children || [];\n              const childDefinition = this.toFieldDefinition(\n                submodel || Clazz,\n                globalProps,\n                false\n              );\n              children.push(\n                childDefinition as FieldDefinition<Record<string, any>>\n              );\n              break;\n            }\n            case UIKeys.UILISTPROP: {\n              mapper = mapper || {};\n              mapper[dec.props?.name as string] = key;\n              const props = Object.assign(\n                {},\n                classDecorator.props?.item || {},\n                item?.props || {},\n                dec.props?.props || {},\n                globalProps\n              );\n              childProps = {\n                tag: item?.tag || props.render || \"\",\n                props: Object.assign({}, childProps?.props, { mapper }, props),\n              };\n\n              break;\n            }\n            case UIKeys.ELEMENT: {\n              children = children || [];\n              const childDefinition: FieldDefinition<Record<string, any>> = {\n                tag: (dec.props as UIElementMetadata).tag,\n                props: Object.assign(\n                  {},\n                  (dec.props as UIElementMetadata).props as any,\n                  globalProps\n                ),\n              };\n\n              const validationDecs: DecoratorMetadata<ValidationMetadata>[] =\n                validationDecorators[\n                  key\n                ] as DecoratorMetadata<ValidationMetadata>[];\n\n              const typeDec: DecoratorMetadataObject =\n                validationDecs.shift() as DecoratorMetadata;\n              for (const dec of validationDecs) {\n                if (this.isValidatableByAttribute(dec.key)) {\n                  childDefinition.props[this.translate(dec.key)] =\n                    this.toAttributeValue(dec.key, dec.props);\n                  continue;\n                }\n                if (this.isValidatableByType(dec.key)) {\n                  if (dec.key === HTML5InputTypes.DATE) {\n                    childDefinition.props[UIKeys.FORMAT] =\n                      dec.props.format || HTML5DateFormat;\n                  }\n                  childDefinition.props[UIKeys.TYPE] = dec.key;\n                  continue;\n                }\n              }\n\n              if (!childDefinition.props[UIKeys.TYPE]) {\n                const basicType = (typeDec.props as { name: string }).name;\n                childDefinition.props[UIKeys.TYPE] = this.translate(\n                  basicType.toLowerCase(),\n                  true\n                );\n              }\n\n              childDefinition.props.value = formatByType(\n                childDefinition.props[UIKeys.TYPE],\n                model[key as keyof M],\n                childDefinition.props[UIKeys.FORMAT]\n              );\n\n              children.push(childDefinition);\n              break;\n            }\n            default:\n              throw new RenderingError(`Invalid key: ${dec.key}`);\n          }\n        });\n      }\n    }\n\n    const result: FieldDefinition<T> = {\n      tag: tag,\n      item: childProps as UIListItemElementMetadata,\n      props: Object.assign({}, props, globalProps) as T & FieldProperties,\n      children: children as FieldDefinition<any>[],\n    };\n\n    if (generateId) result.rendererId = generateUIModelID(model);\n\n    return result;\n  }\n\n  /**\n   * @description Renders a model with global properties and additional arguments.\n   * @summary Abstract method to be implemented by subclasses to define specific rendering behavior.\n   *\n   * @template M Type extending Model\n   * @template R Rendering engine implementation specific output type\n   * @param {M} model - The model to be rendered.\n   * @param {Record<string, unknown>} globalProps - Global properties to be applied to all elements during rendering.\n   * @param {...any[]} args - Additional arguments that may be required for specific rendering implementations.\n   * @returns {R} The rendered result, type depends on the specific implementation.\n   *\n   * @abstract\n   */\n  abstract render<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown>,\n    ...args: any[]\n  ): R;\n\n  /**\n   * @description Registers a rendering engine instance.\n   * @summary Adds a rendering engine to the static cache and sets it as the current engine.\n   *\n   * @param {RenderingEngine<unknown, unknown>} engine - The rendering engine to register.\n   * @throws {InternalError} If an engine with the same flavor already exists.\n   *\n   * @static\n   */\n  static register(engine: RenderingEngine<unknown, unknown>) {\n    if (engine.flavour in this.cache)\n      throw new InternalError(\n        `Rendering engine under ${engine.flavour} already exists`\n      );\n    this.cache[engine.flavour] = engine;\n    this.current = engine;\n  }\n\n  /**\n   * @description Retrieves or initializes a rendering engine.\n   * @summary Gets an existing engine instance or creates and initializes a new one if given a constructor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {Constructor<RenderingEngine<O>> | RenderingEngine<O>} obj - The engine instance or constructor.\n   * @returns {RenderingEngine<O>} The initialized rendering engine.\n   *\n   * @private\n   * @static\n   */\n  private static getOrBoot<O>(\n    obj: Constructor<RenderingEngine<O>> | RenderingEngine<O>\n  ): RenderingEngine<O> {\n    if (obj instanceof RenderingEngine) return obj as RenderingEngine<O>;\n    const engine: RenderingEngine<O> = new obj();\n    engine.initialize(); // make the booting async. use the initialized flag to control it\n    return engine as RenderingEngine<O>;\n  }\n\n  /**\n   * @description Retrieves a rendering engine by flavor.\n   * @summary Gets the current rendering engine or a specific one by flavor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {string} [flavour] - The flavor of the rendering engine to retrieve.\n   * @returns {RenderingEngine<O>} The requested rendering engine.\n   * @throws {InternalError} If the requested flavor does not exist.\n   *\n   * @static\n   */\n  static get<O>(flavour?: string): RenderingEngine<O> {\n    if (!flavour)\n      return this.getOrBoot<O>(\n        this.current as Constructor<RenderingEngine<O>> | RenderingEngine<O>\n      );\n    if (!(flavour in this.cache))\n      throw new InternalError(\n        `Rendering engine under ${flavour} does not exist`\n      );\n    return this.getOrBoot<O>(\n      this.cache[flavour] as\n        | Constructor<RenderingEngine<O>>\n        | RenderingEngine<O>\n    );\n  }\n\n  /**\n   * @description Renders a model using the appropriate rendering engine.\n   * @summary Determines the correct rendering engine for a model and invokes its render method.\n   *\n   * @template M Type extending Model\n   * @param {M} model - The model to render.\n   * @param {...any[]} args - Additional arguments to pass to the render method.\n   * @returns {any} The result of the rendering process.\n   * @throws {InternalError} If no registered model is found.\n   *\n   * @static\n   */\n  static render<M extends Model>(model: M, ...args: any[]): any {\n    const constructor = Model.get(model.constructor.name);\n    if (!constructor) throw new InternalError(\"No model registered found\");\n    const flavour = Reflect.getMetadata(\n      RenderingEngine.key(UIKeys.RENDERED_BY),\n      constructor as ModelConstructor<Model>\n    );\n\n    // @ts-expect-error for the var args type check\n    return RenderingEngine.get(flavour).render(model, ...args);\n  }\n\n  /**\n   * @description Generates a metadata key for UI-related properties.\n   * @summary Prefixes a given key with the UI reflection prefix.\n   *\n   * @param {string} key - The key to prefix.\n   * @returns {string} The prefixed key.\n   *\n   * @static\n   */\n  static key(key: string): string {\n    return `${UIKeys.REFLECT}${key}`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Rendering.js","sourceRoot":"","sources":["../../../src/ui/Rendering.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalError } from \"@decaf-ts/db-decorators\";\nimport {\n  Constructor,\n  Model,\n  ModelConstructor,\n  ReservedModels,\n  ValidationKeys,\n  ValidationMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  HTML5DateFormat,\n  HTML5InputTypes,\n  UIKeys,\n  ValidatableByAttribute,\n  ValidatableByType,\n} from \"./constants\";\nimport {\n  FieldDefinition,\n  FieldProperties,\n  UIElementMetadata,\n  UIListItemElementMetadata,\n  UIListItemModelMetadata,\n  UIModelMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { RenderingError } from \"./errors\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { formatByType, generateUIModelID } from \"./utils\";\n\n/**\n * @description Abstract class for rendering UI components based on model metadata.\n * @summary The RenderingEngine class provides a framework for converting model metadata into UI field definitions.\n * It handles the translation of model properties to UI elements, applies validation rules, and manages different rendering flavors.\n * This class is designed to be extended by specific rendering implementations.\n *\n * @template T The type of the rendering result, defaults to void\n * @template R The type of the field definition, defaults to FieldDefinition<T>\n *\n * @param {string} flavour - The flavor of the rendering engine.\n *\n * @class RenderingEngine\n */\nexport abstract class RenderingEngine<T = void, R = FieldDefinition<T>> {\n  /**\n   * @description Cache for storing rendering engine instances or constructors.\n   * @private\n   * @static\n   */\n  private static cache: Record<\n    string,\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>\n  > = {};\n\n  /**\n   * @description The currently active rendering engine.\n   * @private\n   * @static\n   */\n  private static current:\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>;\n\n  /**\n   * Flag indicating whether the rendering engine has been initialized.\n   */\n  protected initialized: boolean = false;\n\n  protected constructor(readonly flavour: string) {\n    RenderingEngine.register(this);\n    console.log(`decaf's ${flavour} rendering engine loaded`);\n  }\n\n  /**\n   * @description Initializes the rendering engine.\n   * @summary Abstract method to be implemented by subclasses for specific initialization logic.\n   *\n   * @param {...any[]} args - Any additional arguments needed for initialization.\n   * @returns {Promise<void>} A promise that resolves when initialization is complete.\n   *\n   * @abstract\n   */\n  abstract initialize(...args: any[]): Promise<void>;\n\n  /**\n   * @description Translates between model types and HTML input types.\n   * @summary Converts model data types to appropriate HTML input types and vice versa.\n   *\n   * @param {string} key - The key to translate.\n   * @param {boolean} [toView=true] - Direction of translation (true for model to view, false for view to model).\n   * @returns {string} The translated type.\n   */\n  translate(key: string, toView: boolean = true): string {\n    if (toView) {\n      switch (key) {\n        case ReservedModels.STRING:\n          return HTML5InputTypes.TEXT;\n        case ReservedModels.NUMBER:\n        case ReservedModels.BIGINT:\n          return HTML5InputTypes.NUMBER;\n        case ReservedModels.BOOLEAN:\n          return HTML5InputTypes.CHECKBOX;\n        case ReservedModels.DATE:\n          return HTML5InputTypes.DATE;\n      }\n    } else {\n      switch (key) {\n        case HTML5InputTypes.TEXT:\n        case HTML5InputTypes.EMAIL:\n        case HTML5InputTypes.COLOR:\n        case HTML5InputTypes.PASSWORD:\n        case HTML5InputTypes.TEL:\n        case HTML5InputTypes.URL:\n          return ReservedModels.STRING;\n        case HTML5InputTypes.NUMBER:\n          return ReservedModels.NUMBER;\n        case HTML5InputTypes.CHECKBOX:\n          return ReservedModels.BOOLEAN;\n        case HTML5InputTypes.DATE:\n        case HTML5InputTypes.DATETIME_LOCAL:\n        case HTML5InputTypes.TIME:\n          return ReservedModels.DATE;\n      }\n    }\n    return key;\n  }\n\n  /**\n   * @description Checks if a type is validatable by its nature.\n   * @summary Determines if a given UI key represents a type that is inherently validatable.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable, false otherwise.\n   */\n  protected isValidatableByType(key: string): boolean {\n    return Object.keys(ValidatableByType).includes(key);\n  }\n\n  /**\n   * @description Checks if a type is validatable by attribute.\n   * @summary Determines if a given UI key represents a validation that can be applied as an attribute.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable by attribute, false otherwise.\n   */\n  protected isValidatableByAttribute(key: string): boolean {\n    return Object.keys(ValidatableByAttribute).includes(key);\n  }\n\n  /**\n   * @description Converts validation metadata to an attribute value.\n   * @summary Transforms validation metadata into a value suitable for use as an HTML attribute.\n   *\n   * @param {string} key - The validation key.\n   * @param {ValidationMetadata} value - The validation metadata.\n   * @returns {string | number | boolean} The converted attribute value.\n   * @throws {Error} If the given key is not validatable by attribute.\n   */\n  protected toAttributeValue(\n    key: string,\n    value: ValidationMetadata\n  ): string | number | boolean {\n    if (!Object.keys(ValidatableByAttribute).includes(key))\n      throw new Error(\n        `Invalid attribute key \"${key}\". Expected one of: ${Object.keys(ValidatableByAttribute).join(\", \")}.`\n      );\n\n    return key === UIKeys.REQUIRED ? true : value[key];\n  }\n\n  /**\n   * @description Converts a model to a field definition.\n   * @summary Processes a model instance, extracting UI-related metadata and validation rules to create a field definition.\n   *\n   * @template M Type extending Model\n   * @template T Type referencing the specific Rendering engine field properties/inputs\n   * @param {M} model - The model instance to convert.\n   * @param {Record<string, unknown>} [globalProps={}] - Global properties to apply to all child elements.\n   * @param {boolean} [generateId=true] - Flag indicating whether to populate the rendererId property.\n   * @returns {FieldDefinition<T>} A field definition object representing the UI structure of the model.\n   * @throws {RenderingError} If no UI definitions are set for the model or if there are invalid decorators.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *  participant C as Client\n   *  participant RE as RenderingEngine\n   *  participant R as Reflection\n   *  participant M as Model\n   *  C->>RE: toFieldDefinition(model, globalProps)\n   *  RE->>R: getMetadata(UIKeys.UIMODEL, model.constructor)\n   *  R-->>RE: UIModelMetadata\n   *  RE->>R: getAllPropertyDecorators(model, UIKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata[]>\n   *  RE->>R: getAllPropertyDecorators(model, ValidationKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata<ValidationMetadata>[]>\n   *  loop For each property\n   *    RE->>RE: Process UI decorators\n   *    RE->>RE: Apply validation rules\n   *  end\n   *  RE-->>C: FieldDefinition<T>\n   */\n  protected toFieldDefinition<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown> = {},\n    generateId: boolean = true\n  ): FieldDefinition<T> {\n    const classDecorators: [UIModelMetadata, UIListItemModelMetadata] = [\n      Reflect.getMetadata(\n        RenderingEngine.key(UIKeys.UIMODEL),\n        model.constructor\n      ) ||\n        Reflect.getMetadata(\n          RenderingEngine.key(UIKeys.UIMODEL),\n          Model.get(model.constructor.name) as any\n        ),\n      Reflect.getMetadata(\n        RenderingEngine.key(UIKeys.UILISTITEM),\n        model.constructor\n      ) ||\n        Reflect.getMetadata(\n          RenderingEngine.key(UIKeys.UILISTITEM),\n          Model.get(model.constructor.name) as any\n        ),\n    ];\n\n    if (!classDecorators)\n      throw new RenderingError(\n        `No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`\n      );\n\n    const classDecorator = Object.assign({}, ...classDecorators);\n    const { tag, props, item } = classDecorator;\n\n    const uiDecorators: Record<string, DecoratorMetadata[]> =\n      Reflection.getAllPropertyDecorators(model, UIKeys.REFLECT) as Record<\n        string,\n        DecoratorMetadata[]\n      >;\n    let children: FieldDefinition<Record<string, any>>[] | undefined;\n    let childProps: Record<string, any> = item?.props || {};\n    let mapper: Record<string, string> = {};\n\n    const getPath = (parent: string | undefined, prop: string) => {\n      return parent ? [parent, prop].join(\".\") : prop;\n    };\n\n    if (uiDecorators) {\n      const validationDecorators: Record<\n        string,\n        DecoratorMetadata<ValidationMetadata>[]\n      > = Reflection.getAllPropertyDecorators(\n        model,\n        ValidationKeys.REFLECT\n      ) as Record<string, DecoratorMetadata<ValidationMetadata>[]>;\n\n      for (const key in uiDecorators) {\n        const decs = uiDecorators[key];\n        const types = Object.values(decs).filter(\n          (item) => item.key === UIKeys.PROP || item.key === UIKeys.ELEMENT\n        );\n        if (types?.length > 1)\n          throw new RenderingError(\n            `Only one type of decoration is allowed. Please choose between @uiprop and @uielement`\n          );\n        decs.shift();\n        decs.forEach((dec) => {\n          if (!dec) throw new RenderingError(`No decorator found`);\n\n          switch (dec.key) {\n            case UIKeys.PROP: {\n              if (!Model.isPropertyModel(model, key)) {\n                childProps[key] = dec.props as UIPropMetadata;\n                break;\n              }\n\n              let Clazz;\n              const submodel = (model as Record<string, any>)[key] as Model;\n              const constructable =\n                typeof submodel === \"object\" &&\n                submodel !== null &&\n                !Array.isArray(submodel);\n              if (!constructable)\n                Clazz = new (Model.get(\n                  dec.props?.name as string\n                ) as ModelConstructor<Model>)();\n\n              children = children || [];\n              const childrenGlobalProps = Object.assign({}, globalProps || {}, {\n                childOf: getPath(globalProps?.childOf as string, key),\n              });\n              const childDefinition = this.toFieldDefinition(\n                submodel || Clazz,\n                childrenGlobalProps,\n                false\n              );\n              children.push(\n                childDefinition as FieldDefinition<Record<string, any>>\n              );\n              break;\n            }\n            case UIKeys.UILISTPROP: {\n              mapper = mapper || {};\n              mapper[dec.props?.name as string] = key;\n              const props = Object.assign(\n                {},\n                classDecorator.props?.item || {},\n                item?.props || {},\n                dec.props?.props || {},\n                globalProps\n              );\n              childProps = {\n                tag: item?.tag || props.render || \"\",\n                props: Object.assign({}, childProps?.props, { mapper }, props),\n              };\n\n              break;\n            }\n            case UIKeys.ELEMENT: {\n              children = children || [];\n\n              const uiProps: UIElementMetadata = dec.props as UIElementMetadata;\n              const props = Object.assign(\n                {},\n                uiProps.props as any,\n                {\n                  path: getPath(\n                    globalProps?.childOf as string,\n                    uiProps.props!.name\n                  ),\n                  childOf: undefined, // The childOf prop is passed by globalProps when it is a nested prop\n                },\n                globalProps\n              );\n\n              const childDefinition: FieldDefinition<Record<string, any>> = {\n                tag: uiProps.tag,\n                props,\n              };\n\n              const validationDecs: DecoratorMetadata<ValidationMetadata>[] =\n                validationDecorators[\n                  key\n                ] as DecoratorMetadata<ValidationMetadata>[];\n\n              const typeDec: DecoratorMetadataObject =\n                validationDecs.shift() as DecoratorMetadata;\n              for (const dec of validationDecs) {\n                if (this.isValidatableByAttribute(dec.key)) {\n                  childDefinition.props[this.translate(dec.key)] =\n                    this.toAttributeValue(dec.key, dec.props);\n                  continue;\n                }\n                if (this.isValidatableByType(dec.key)) {\n                  if (dec.key === HTML5InputTypes.DATE) {\n                    childDefinition.props[UIKeys.FORMAT] =\n                      dec.props.format || HTML5DateFormat;\n                  }\n                  childDefinition.props[UIKeys.TYPE] = dec.key;\n                  continue;\n                }\n              }\n\n              if (!childDefinition.props[UIKeys.TYPE]) {\n                const basicType = (typeDec.props as { name: string }).name;\n                childDefinition.props[UIKeys.TYPE] = this.translate(\n                  basicType.toLowerCase(),\n                  true\n                );\n              }\n\n              childDefinition.props.value = formatByType(\n                childDefinition.props[UIKeys.TYPE],\n                model[key as keyof M],\n                childDefinition.props[UIKeys.FORMAT]\n              );\n\n              children.push(childDefinition);\n              break;\n            }\n            default:\n              throw new RenderingError(`Invalid key: ${dec.key}`);\n          }\n        });\n      }\n    }\n\n    const result: FieldDefinition<T> = {\n      tag: tag,\n      item: childProps as UIListItemElementMetadata,\n      props: Object.assign({}, props, globalProps) as T & FieldProperties,\n      children: children as FieldDefinition<any>[],\n    };\n\n    if (generateId) result.rendererId = generateUIModelID(model);\n\n    return result;\n  }\n\n  /**\n   * @description Renders a model with global properties and additional arguments.\n   * @summary Abstract method to be implemented by subclasses to define specific rendering behavior.\n   *\n   * @template M Type extending Model\n   * @template R Rendering engine implementation specific output type\n   * @param {M} model - The model to be rendered.\n   * @param {Record<string, unknown>} globalProps - Global properties to be applied to all elements during rendering.\n   * @param {...any[]} args - Additional arguments that may be required for specific rendering implementations.\n   * @returns {R} The rendered result, type depends on the specific implementation.\n   *\n   * @abstract\n   */\n  abstract render<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown>,\n    ...args: any[]\n  ): R;\n\n  /**\n   * @description Registers a rendering engine instance.\n   * @summary Adds a rendering engine to the static cache and sets it as the current engine.\n   *\n   * @param {RenderingEngine<unknown, unknown>} engine - The rendering engine to register.\n   * @throws {InternalError} If an engine with the same flavor already exists.\n   *\n   * @static\n   */\n  static register(engine: RenderingEngine<unknown, unknown>) {\n    if (engine.flavour in this.cache)\n      throw new InternalError(\n        `Rendering engine under ${engine.flavour} already exists`\n      );\n    this.cache[engine.flavour] = engine;\n    this.current = engine;\n  }\n\n  /**\n   * @description Retrieves or initializes a rendering engine.\n   * @summary Gets an existing engine instance or creates and initializes a new one if given a constructor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {Constructor<RenderingEngine<O>> | RenderingEngine<O>} obj - The engine instance or constructor.\n   * @returns {RenderingEngine<O>} The initialized rendering engine.\n   *\n   * @private\n   * @static\n   */\n  private static getOrBoot<O>(\n    obj: Constructor<RenderingEngine<O>> | RenderingEngine<O>\n  ): RenderingEngine<O> {\n    if (obj instanceof RenderingEngine) return obj as RenderingEngine<O>;\n    const engine: RenderingEngine<O> = new obj();\n    engine.initialize(); // make the booting async. use the initialized flag to control it\n    return engine as RenderingEngine<O>;\n  }\n\n  /**\n   * @description Retrieves a rendering engine by flavor.\n   * @summary Gets the current rendering engine or a specific one by flavor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {string} [flavour] - The flavor of the rendering engine to retrieve.\n   * @returns {RenderingEngine<O>} The requested rendering engine.\n   * @throws {InternalError} If the requested flavor does not exist.\n   *\n   * @static\n   */\n  static get<O>(flavour?: string): RenderingEngine<O> {\n    if (!flavour)\n      return this.getOrBoot<O>(\n        this.current as Constructor<RenderingEngine<O>> | RenderingEngine<O>\n      );\n    if (!(flavour in this.cache))\n      throw new InternalError(\n        `Rendering engine under ${flavour} does not exist`\n      );\n    return this.getOrBoot<O>(\n      this.cache[flavour] as\n        | Constructor<RenderingEngine<O>>\n        | RenderingEngine<O>\n    );\n  }\n\n  /**\n   * @description Renders a model using the appropriate rendering engine.\n   * @summary Determines the correct rendering engine for a model and invokes its render method.\n   *\n   * @template M Type extending Model\n   * @param {M} model - The model to render.\n   * @param {...any[]} args - Additional arguments to pass to the render method.\n   * @returns {any} The result of the rendering process.\n   * @throws {InternalError} If no registered model is found.\n   *\n   * @static\n   */\n  static render<M extends Model>(model: M, ...args: any[]): any {\n    const constructor = Model.get(model.constructor.name);\n    if (!constructor) throw new InternalError(\"No model registered found\");\n    const flavour = Reflect.getMetadata(\n      RenderingEngine.key(UIKeys.RENDERED_BY),\n      constructor as ModelConstructor<Model>\n    );\n\n    // @ts-expect-error for the var args type check\n    return RenderingEngine.get(flavour).render(model, ...args);\n  }\n\n  /**\n   * @description Generates a metadata key for UI-related properties.\n   * @summary Prefixes a given key with the UI reflection prefix.\n   *\n   * @param {string} key - The key to prefix.\n   * @returns {string} The prefixed key.\n   *\n   * @static\n   */\n  static key(key: string): string {\n    return `${UIKeys.REFLECT}${key}`;\n  }\n}\n"]}