@decaf-ts/ui-decorators 0.4.5 → 0.5.0

package/lib/esm/ui/Rendering.js

@@ -0,0 +1,297 @@
+import { InternalError } from "@decaf-ts/db-decorators";
+import { Model, ReservedModels, ValidationKeys, } from "@decaf-ts/decorator-validation";
+import { HTML5DateFormat, HTML5InputTypes, UIKeys, ValidatableByAttribute, ValidatableByType, } from "./constants";
+import { RenderingError } from "./errors";
+import { Reflection } from "@decaf-ts/reflection";
+import { formatByType, generateUIModelID } from "./utils";
+/**
+ * @description Abstract class for rendering UI components based on model metadata.
+ * @summary The RenderingEngine class provides a framework for converting model metadata into UI field definitions.
+ * It handles the translation of model properties to UI elements, applies validation rules, and manages different rendering flavors.
+ * This class is designed to be extended by specific rendering implementations.
+ *
+ * @template T The type of the rendering result, defaults to void
+ * @template R The type of the field definition, defaults to FieldDefinition<T>
+ *
+ * @param {string} flavour - The flavor of the rendering engine.
+ *
+ * @class RenderingEngine
+ */
+export class RenderingEngine {
+    /**
+     * @description Cache for storing rendering engine instances or constructors.
+     * @private
+     * @static
+     */
+    static { this.cache = {}; }
+    constructor(flavour) {
+        this.flavour = flavour;
+        /**
+         * Flag indicating whether the rendering engine has been initialized.
+         */
+        this.initialized = false;
+        RenderingEngine.register(this);
+        console.log(`decaf's ${flavour} rendering engine loaded`);
+    }
+    /**
+     * @description Translates between model types and HTML input types.
+     * @summary Converts model data types to appropriate HTML input types and vice versa.
+     *
+     * @param {string} key - The key to translate.
+     * @param {boolean} [toView=true] - Direction of translation (true for model to view, false for view to model).
+     * @returns {string} The translated type.
+     */
+    translate(key, toView = true) {
+        if (toView) {
+            switch (key) {
+                case ReservedModels.STRING:
+                    return HTML5InputTypes.TEXT;
+                case ReservedModels.NUMBER:
+                case ReservedModels.BIGINT:
+                    return HTML5InputTypes.NUMBER;
+                case ReservedModels.BOOLEAN:
+                    return HTML5InputTypes.CHECKBOX;
+                case ReservedModels.DATE:
+                    return HTML5InputTypes.DATE;
+            }
+        }
+        else {
+            switch (key) {
+                case HTML5InputTypes.TEXT:
+                case HTML5InputTypes.EMAIL:
+                case HTML5InputTypes.COLOR:
+                case HTML5InputTypes.PASSWORD:
+                case HTML5InputTypes.TEL:
+                case HTML5InputTypes.URL:
+                    return ReservedModels.STRING;
+                case HTML5InputTypes.NUMBER:
+                    return ReservedModels.NUMBER;
+                case HTML5InputTypes.CHECKBOX:
+                    return ReservedModels.BOOLEAN;
+                case HTML5InputTypes.DATE:
+                case HTML5InputTypes.DATETIME_LOCAL:
+                case HTML5InputTypes.TIME:
+                    return ReservedModels.DATE;
+            }
+        }
+        return key;
+    }
+    /**
+     * @description Checks if a type is validatable by its nature.
+     * @summary Determines if a given UI key represents a type that is inherently validatable.
+     *
+     * @param {string} key - The UI key to check.
+     * @returns {boolean} True if the type is validatable, false otherwise.
+     */
+    isValidatableByType(key) {
+        return Object.keys(ValidatableByType).includes(key);
+    }
+    /**
+     * @description Checks if a type is validatable by attribute.
+     * @summary Determines if a given UI key represents a validation that can be applied as an attribute.
+     *
+     * @param {string} key - The UI key to check.
+     * @returns {boolean} True if the type is validatable by attribute, false otherwise.
+     */
+    isValidatableByAttribute(key) {
+        return Object.keys(ValidatableByAttribute).includes(key);
+    }
+    /**
+     * @description Converts validation metadata to an attribute value.
+     * @summary Transforms validation metadata into a value suitable for use as an HTML attribute.
+     *
+     * @param {string} key - The validation key.
+     * @param {ValidationMetadata} value - The validation metadata.
+     * @returns {string | number | boolean} The converted attribute value.
+     * @throws {Error} If the given key is not validatable by attribute.
+     */
+    toAttributeValue(key, value) {
+        if (!Object.keys(ValidatableByAttribute).includes(key))
+            throw new Error(`Invalid attribute key "${key}". Expected one of: ${Object.keys(ValidatableByAttribute).join(", ")}.`);
+        return key === UIKeys.REQUIRED ? true : value[key];
+    }
+    /**
+     * @description Converts a model to a field definition.
+     * @summary Processes a model instance, extracting UI-related metadata and validation rules to create a field definition.
+     *
+     * @template M Type extending Model
+     * @template T Type referencing the specific Rendering engine field properties/inputs
+     * @param {M} model - The model instance to convert.
+     * @param {Record<string, unknown>} [globalProps={}] - Global properties to apply to all child elements.
+     * @param {boolean} [generateId=true] - Flag indicating whether to populate the rendererId property.
+     * @returns {FieldDefinition<T>} A field definition object representing the UI structure of the model.
+     * @throws {RenderingError} If no UI definitions are set for the model or if there are invalid decorators.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *  participant C as Client
+     *  participant RE as RenderingEngine
+     *  participant R as Reflection
+     *  participant M as Model
+     *  C->>RE: toFieldDefinition(model, globalProps)
+     *  RE->>R: getMetadata(UIKeys.UIMODEL, model.constructor)
+     *  R-->>RE: UIModelMetadata
+     *  RE->>R: getAllPropertyDecorators(model, UIKeys.REFLECT)
+     *  R-->>RE: Record<string, DecoratorMetadata[]>
+     *  RE->>R: getAllPropertyDecorators(model, ValidationKeys.REFLECT)
+     *  R-->>RE: Record<string, DecoratorMetadata<ValidationMetadata>[]>
+     *  loop For each property
+     *    RE->>RE: Process UI decorators
+     *    RE->>RE: Apply validation rules
+     *  end
+     *  RE-->>C: FieldDefinition<T>
+     */
+    toFieldDefinition(model, globalProps = {}, generateId = true) {
+        const classDecorator = Reflect.getMetadata(RenderingEngine.key(UIKeys.UIMODEL), model.constructor) ||
+            Reflect.getMetadata(RenderingEngine.key(UIKeys.UIMODEL), Model.get(model.constructor.name));
+        if (!classDecorator)
+            throw new RenderingError(`No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`);
+        const { tag, props } = classDecorator;
+        const uiDecorators = Reflection.getAllPropertyDecorators(model, UIKeys.REFLECT);
+        let children;
+        const childProps = {};
+        if (uiDecorators) {
+            const validationDecorators = Reflection.getAllPropertyDecorators(model, ValidationKeys.REFLECT);
+            for (const key in uiDecorators) {
+                const decs = uiDecorators[key];
+                if (decs.length !== 2)
+                    throw new RenderingError(`Only one type of decoration is allowed. Please choose between @uiprop and @uielement`);
+                const dec = decs[1]; // Ignore 0, its the design:type
+                if (!dec)
+                    throw new RenderingError(`No decorator found`);
+                switch (dec.key) {
+                    case UIKeys.PROP:
+                        childProps[key] = dec.props;
+                        break;
+                    case UIKeys.ELEMENT: {
+                        children = children || [];
+                        const childDefinition = {
+                            tag: dec.props.tag,
+                            props: Object.assign({}, dec.props.props, globalProps),
+                        };
+                        const validationDecs = validationDecorators[key];
+                        const typeDec = validationDecs.shift();
+                        for (const dec of validationDecs) {
+                            if (this.isValidatableByAttribute(dec.key)) {
+                                childDefinition.props[this.translate(dec.key)] =
+                                    this.toAttributeValue(dec.key, dec.props);
+                                continue;
+                            }
+                            if (this.isValidatableByType(dec.key)) {
+                                if (dec.key === HTML5InputTypes.DATE) {
+                                    childDefinition.props[UIKeys.FORMAT] =
+                                        dec.props.format || HTML5DateFormat;
+                                }
+                                childDefinition.props[UIKeys.TYPE] = dec.key;
+                                continue;
+                            }
+                            console.log(dec);
+                        }
+                        if (!childDefinition.props[UIKeys.TYPE]) {
+                            const basicType = typeDec.props.name;
+                            childDefinition.props[UIKeys.TYPE] = this.translate(basicType.toLowerCase(), true);
+                        }
+                        childDefinition.props.value = formatByType(childDefinition.props[UIKeys.TYPE], model[key], childDefinition.props[UIKeys.FORMAT]);
+                        children.push(childDefinition);
+                        break;
+                    }
+                    default:
+                        throw new RenderingError(`Invalid key: ${dec.key}`);
+                }
+            }
+        }
+        const result = {
+            tag: tag,
+            props: Object.assign({}, props, globalProps),
+            children: children,
+        };
+        if (generateId) {
+            result.rendererId = generateUIModelID(model);
+        }
+        return result;
+    }
+    /**
+     * @description Registers a rendering engine instance.
+     * @summary Adds a rendering engine to the static cache and sets it as the current engine.
+     *
+     * @param {RenderingEngine<unknown, unknown>} engine - The rendering engine to register.
+     * @throws {InternalError} If an engine with the same flavor already exists.
+     *
+     * @static
+     */
+    static register(engine) {
+        if (engine.flavour in this.cache)
+            throw new InternalError(`Rendering engine under ${engine.flavour} already exists`);
+        this.cache[engine.flavour] = engine;
+        this.current = engine;
+    }
+    /**
+     * @description Retrieves or initializes a rendering engine.
+     * @summary Gets an existing engine instance or creates and initializes a new one if given a constructor.
+     *
+     * @template O The type of the rendering engine output
+     * @param {Constructor<RenderingEngine<O>> | RenderingEngine<O>} obj - The engine instance or constructor.
+     * @returns {RenderingEngine<O>} The initialized rendering engine.
+     *
+     * @private
+     * @static
+     */
+    static getOrBoot(obj) {
+        if (obj instanceof RenderingEngine)
+            return obj;
+        const engine = new obj();
+        engine.initialize(); // make the booting async. use the initialized flag to control it
+        return engine;
+    }
+    /**
+     * @description Retrieves a rendering engine by flavor.
+     * @summary Gets the current rendering engine or a specific one by flavor.
+     *
+     * @template O The type of the rendering engine output
+     * @param {string} [flavour] - The flavor of the rendering engine to retrieve.
+     * @returns {RenderingEngine<O>} The requested rendering engine.
+     * @throws {InternalError} If the requested flavor does not exist.
+     *
+     * @static
+     */
+    static get(flavour) {
+        if (!flavour)
+            return this.getOrBoot(this.current);
+        if (!(flavour in this.cache))
+            throw new InternalError(`Rendering engine under ${flavour} does not exist`);
+        return this.getOrBoot(this.cache[flavour]);
+    }
+    /**
+     * @description Renders a model using the appropriate rendering engine.
+     * @summary Determines the correct rendering engine for a model and invokes its render method.
+     *
+     * @template M Type extending Model
+     * @param {M} model - The model to render.
+     * @param {...any[]} args - Additional arguments to pass to the render method.
+     * @returns {any} The result of the rendering process.
+     * @throws {InternalError} If no registered model is found.
+     *
+     * @static
+     */
+    static render(model, ...args) {
+        const constructor = Model.get(model.constructor.name);
+        if (!constructor)
+            throw new InternalError("No model registered found");
+        const flavour = Reflect.getMetadata(RenderingEngine.key(UIKeys.RENDERED_BY), constructor);
+        // @ts-expect-error for the var args type check
+        return RenderingEngine.get(flavour).render(model, ...args);
+    }
+    /**
+     * @description Generates a metadata key for UI-related properties.
+     * @summary Prefixes a given key with the UI reflection prefix.
+     *
+     * @param {string} key - The key to prefix.
+     * @returns {string} The prefixed key.
+     *
+     * @static
+     */
+    static key(key) {
+        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  UIModelMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { RenderingError } from \"./errors\";\nimport { Reflection, DecoratorMetadata } 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 classDecorator: UIModelMetadata =\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\n    if (!classDecorator)\n      throw new RenderingError(\n        `No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`\n      );\n\n    const { tag, props } = 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    const childProps: Record<string, any> = {};\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        if (decs.length !== 2)\n          throw new RenderingError(\n            `Only one type of decoration is allowed. Please choose between @uiprop and @uielement`\n          );\n        const dec = decs[1]; // Ignore 0, its the design:type\n        if (!dec) throw new RenderingError(`No decorator found`);\n        switch (dec.key) {\n          case UIKeys.PROP:\n            childProps[key] = dec.props as UIPropMetadata;\n            break;\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              console.log(dec);\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    const result: FieldDefinition<T> = {\n      tag: tag,\n      props: Object.assign({}, props, globalProps) as T & FieldProperties,\n      children: children as FieldDefinition<any>[],\n    };\n\n    if (generateId) {\n      result.rendererId = generateUIModelID(model);\n    }\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\n"]}

package/lib/esm/ui/constants.d.ts

@@ -0,0 +1,64 @@
+import { Constructor, Validator } from "@decaf-ts/decorator-validation";
+/**
+ * @enum UIKeys
+ * @category Constants
+ */
+export declare const UIKeys: {
+    REFLECT: string;
+    UIMODEL: string;
+    RENDERED_BY: string;
+    ELEMENT: string;
+    PROP: string;
+    NAME: string;
+    NAME_PREFIX: string;
+    CUSTOM_PROPS: string;
+    TYPE: string;
+    SUB_TYPE: string;
+    HIDDEN: string;
+    FORMAT: string;
+    READ_ONLY: string;
+    REQUIRED: "required";
+    MIN: "min";
+    MIN_LENGTH: "minlength";
+    MAX: "max";
+    MAX_LENGTH: "maxlength";
+    PATTERN: "pattern";
+    URL: "url";
+    STEP: "step";
+    DATE: "date";
+    EMAIL: "email";
+    PASSWORD: "password";
+};
+export declare const ValidatableByType: Record<string, Constructor<Validator>>;
+/**
+ * @constant ValidatableByAttribute
+ *
+ * @memberOf ui-decorators-web.ui
+ */
+export declare const ValidatableByAttribute: Record<string, Constructor<Validator>>;
+export declare const HTML5DateFormat = "yyyy-MM-dd";
+export declare const HTML5InputTypes: {
+    BUTTON: string;
+    CHECKBOX: string;
+    COLOR: string;
+    DATE: "date";
+    DATETIME_LOCAL: string;
+    EMAIL: "email";
+    FILE: string;
+    HIDDEN: string;
+    IMAGE: string;
+    MONTH: string;
+    NUMBER: string;
+    PASSWORD: "password";
+    RADIO: string;
+    RANGE: string;
+    RESET: string;
+    SEARCH: string;
+    SUBMIT: string;
+    TEL: string;
+    TEXT: string;
+    TIME: string;
+    URL: "url";
+    WEEK: string;
+};
+export declare const HTML5CheckTypes: string[];

package/lib/esm/ui/constants.js

@@ -0,0 +1,87 @@
+import { DateValidator, EmailValidator, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, ModelKeys, PasswordValidator, PatternValidator, RequiredValidator, StepValidator, URLValidator, ValidationKeys, } from "@decaf-ts/decorator-validation";
+/**
+ * @enum UIKeys
+ * @category Constants
+ */
+export const UIKeys = {
+    REFLECT: `${ModelKeys.REFLECT}.ui.`,
+    UIMODEL: "uimodel",
+    RENDERED_BY: "rendered-by",
+    ELEMENT: "element",
+    PROP: "prop",
+    NAME: "name",
+    NAME_PREFIX: "input-",
+    CUSTOM_PROPS: "customValidationProps",
+    TYPE: "type",
+    SUB_TYPE: "subtype",
+    HIDDEN: "hidden",
+    FORMAT: "format",
+    READ_ONLY: "readonly",
+    REQUIRED: ValidationKeys.REQUIRED,
+    MIN: ValidationKeys.MIN,
+    MIN_LENGTH: ValidationKeys.MIN_LENGTH,
+    MAX: ValidationKeys.MAX,
+    MAX_LENGTH: ValidationKeys.MAX_LENGTH,
+    PATTERN: ValidationKeys.PATTERN,
+    URL: ValidationKeys.URL,
+    STEP: ValidationKeys.STEP,
+    DATE: ValidationKeys.DATE,
+    EMAIL: ValidationKeys.EMAIL,
+    PASSWORD: ValidationKeys.PASSWORD,
+};
+export const ValidatableByType = [
+    { validationKey: UIKeys.EMAIL, validator: EmailValidator },
+    { validationKey: UIKeys.URL, validator: URLValidator },
+    { validationKey: UIKeys.DATE, validator: DateValidator },
+    { validationKey: UIKeys.PASSWORD, validator: PasswordValidator },
+].reduce((accum, vd) => {
+    accum[vd.validationKey] = vd.validator;
+    return accum;
+}, {});
+/**
+ * @constant ValidatableByAttribute
+ *
+ * @memberOf ui-decorators-web.ui
+ */
+export const ValidatableByAttribute = [
+    { validationKey: UIKeys.REQUIRED, validator: RequiredValidator },
+    { validationKey: UIKeys.MIN, validator: MinValidator },
+    { validationKey: UIKeys.MAX, validator: MaxValidator },
+    { validationKey: UIKeys.STEP, validator: StepValidator },
+    { validationKey: UIKeys.MIN_LENGTH, validator: MinLengthValidator },
+    { validationKey: UIKeys.MAX_LENGTH, validator: MaxLengthValidator },
+    { validationKey: UIKeys.PATTERN, validator: PatternValidator },
+].reduce((accum, vd) => {
+    accum[vd.validationKey] = vd.validator;
+    return accum;
+}, {});
+export const HTML5DateFormat = "yyyy-MM-dd";
+export const HTML5InputTypes = {
+    BUTTON: "button",
+    CHECKBOX: "checkbox",
+    COLOR: "color",
+    DATE: UIKeys.DATE,
+    DATETIME_LOCAL: "datetime-local",
+    EMAIL: UIKeys.EMAIL,
+    FILE: "file",
+    HIDDEN: "hidden",
+    IMAGE: "image",
+    MONTH: "month",
+    NUMBER: "number",
+    PASSWORD: UIKeys.PASSWORD,
+    RADIO: "radio",
+    RANGE: "range",
+    RESET: "reset",
+    SEARCH: "search",
+    SUBMIT: "submit",
+    TEL: "tel",
+    TEXT: "text",
+    TIME: "time",
+    URL: UIKeys.URL,
+    WEEK: "week",
+};
+export const HTML5CheckTypes = [
+    HTML5InputTypes.CHECKBOX,
+    HTML5InputTypes.RADIO,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/ui/decorators.d.ts

@@ -0,0 +1,34 @@
+import "reflect-metadata";
+import { CrudOperationKeys } from "./types";
+/**
+ * @namespace ui-decorators.ui.decorators
+ * @memberOf ui-decorators.ui
+ */
+export declare function hideOn(...operations: CrudOperationKeys[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function hidden(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * Adds the UIElement definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ *
+ * @param {string} tag The component/HTML element tag name
+ * @param {{}} [props] The properties to pass to that component/HTML Element
+ * @param serialize
+ *
+ * @decorator uielement
+ *
+ * @category Decorators
+ * @subcategory ui-decorators
+ */
+export declare function uielement(tag: string, props?: Record<string, any>, serialize?: boolean): (original: any, propertyKey?: any) => void;
+/**
+ * Adds the UIProp definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ *
+ * this requires a '@uimodel' with a defined tag
+ *
+ * @param {string} [propName] the property name that will be passed to the component. defaults to the PropertyKey
+ *
+ * @decorator uiprop
+ *
+ * @category Decorators
+ * @subcategory ui-decorators
+ */
+export declare function uiprop(propName?: string | undefined, stringify?: boolean): (target: any, propertyKey: string) => void;

package/lib/esm/ui/decorators.js

@@ -0,0 +1,61 @@
+import "reflect-metadata";
+import { UIKeys } from "./constants";
+import { propMetadata } from "@decaf-ts/decorator-validation";
+import { RenderingEngine } from "./Rendering";
+import { OperationKeys } from "@decaf-ts/db-decorators";
+/**
+ * @namespace ui-decorators.ui.decorators
+ * @memberOf ui-decorators.ui
+ */
+export function hideOn(...operations) {
+    return propMetadata(RenderingEngine.key(UIKeys.HIDDEN), operations);
+}
+export function hidden() {
+    return hideOn(OperationKeys.CREATE, OperationKeys.READ, OperationKeys.UPDATE, OperationKeys.DELETE);
+}
+/**
+ * Adds the UIElement definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ *
+ * @param {string} tag The component/HTML element tag name
+ * @param {{}} [props] The properties to pass to that component/HTML Element
+ * @param serialize
+ *
+ * @decorator uielement
+ *
+ * @category Decorators
+ * @subcategory ui-decorators
+ */
+export function uielement(tag, props, serialize = false) {
+    return (original, propertyKey) => {
+        const metadata = {
+            tag: tag,
+            serialize: serialize,
+            props: Object.assign({
+                name: propertyKey,
+            }, props || {}),
+        };
+        return propMetadata(RenderingEngine.key(UIKeys.ELEMENT), metadata)(original, propertyKey);
+    };
+}
+/**
+ * Adds the UIProp definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ *
+ * this requires a '@uimodel' with a defined tag
+ *
+ * @param {string} [propName] the property name that will be passed to the component. defaults to the PropertyKey
+ *
+ * @decorator uiprop
+ *
+ * @category Decorators
+ * @subcategory ui-decorators
+ */
+export function uiprop(propName = undefined, stringify = false) {
+    return (target, propertyKey) => {
+        const metadata = {
+            name: propName || propertyKey,
+            stringify: stringify,
+        };
+        propMetadata(RenderingEngine.key(UIKeys.PROP), metadata)(target, propertyKey);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/ui/errors.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export declare class RenderingError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/esm/ui/errors.js

@@ -0,0 +1,7 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export class RenderingError extends BaseError {
+    constructor(msg) {
+        super(RenderingError.name, msg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3VpL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEQsTUFBTSxPQUFPLGNBQWUsU0FBUSxTQUFTO0lBQzNDLFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCBjbGFzcyBSZW5kZXJpbmdFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihSZW5kZXJpbmdFcnJvci5uYW1lLCBtc2cpO1xuICB9XG59XG4iXX0=

package/lib/esm/ui/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @namespace ui-decorators.ui
+ * @memberOf ui-decorators
+ */
+export * from "./constants";
+export * from "./decorators";
+export * from "./errors";
+export * from "./interfaces";
+export * from "./Rendering";
+export * from "./types";
+export * from "./utils";