@decaf-ts/ui-decorators 0.4.6 → 0.5.1

package/dist/ui-decorators.cjs

@@ -0,0 +1,614 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/decorator-validation'), require('@decaf-ts/reflection'), require('@decaf-ts/db-decorators'), require('reflect-metadata')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/decorator-validation', '@decaf-ts/reflection', '@decaf-ts/db-decorators', 'reflect-metadata'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["ui-decorators"] = {}, global.decoratorValidation, global.reflection, global.dbDecorators));
+})(this, (function (exports, decoratorValidation, reflection, dbDecorators) { 'use strict';
+
+    /**
+     * @enum UIKeys
+     * @category Constants
+     */
+    const UIKeys = {
+        REFLECT: `${decoratorValidation.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: decoratorValidation.ValidationKeys.REQUIRED,
+        MIN: decoratorValidation.ValidationKeys.MIN,
+        MIN_LENGTH: decoratorValidation.ValidationKeys.MIN_LENGTH,
+        MAX: decoratorValidation.ValidationKeys.MAX,
+        MAX_LENGTH: decoratorValidation.ValidationKeys.MAX_LENGTH,
+        PATTERN: decoratorValidation.ValidationKeys.PATTERN,
+        URL: decoratorValidation.ValidationKeys.URL,
+        STEP: decoratorValidation.ValidationKeys.STEP,
+        DATE: decoratorValidation.ValidationKeys.DATE,
+        EMAIL: decoratorValidation.ValidationKeys.EMAIL,
+        PASSWORD: decoratorValidation.ValidationKeys.PASSWORD,
+        EQUALS: decoratorValidation.ValidationKeys.EQUALS,
+        DIFF: decoratorValidation.ValidationKeys.DIFF,
+        LESS_THAN: decoratorValidation.ValidationKeys.LESS_THAN,
+        LESS_THAN_OR_EQUAL: decoratorValidation.ValidationKeys.LESS_THAN_OR_EQUAL,
+        GREATER_THAN: decoratorValidation.ValidationKeys.GREATER_THAN,
+        GREATER_THAN_OR_EQUAL: decoratorValidation.ValidationKeys.GREATER_THAN_OR_EQUAL,
+    };
+    const ValidatableByType = {
+        [UIKeys.EMAIL]: decoratorValidation.EmailValidator,
+        [UIKeys.URL]: decoratorValidation.URLValidator,
+        [UIKeys.DATE]: decoratorValidation.DateValidator,
+        [UIKeys.PASSWORD]: decoratorValidation.PasswordValidator,
+    };
+    /**
+     * @constant ValidatableByAttribute
+     *
+     * @memberOf ui-decorators-web.ui
+     */
+    const ValidatableByAttribute = {
+        [UIKeys.REQUIRED]: decoratorValidation.RequiredValidator,
+        [UIKeys.MIN]: decoratorValidation.MinValidator,
+        [UIKeys.MAX]: decoratorValidation.MaxValidator,
+        [UIKeys.STEP]: decoratorValidation.StepValidator,
+        [UIKeys.MIN_LENGTH]: decoratorValidation.MinLengthValidator,
+        [UIKeys.MAX_LENGTH]: decoratorValidation.MaxLengthValidator,
+        [UIKeys.PATTERN]: decoratorValidation.PatternValidator,
+        [UIKeys.EQUALS]: decoratorValidation.EqualsValidator,
+        [UIKeys.DIFF]: decoratorValidation.DiffValidator,
+        [UIKeys.LESS_THAN]: decoratorValidation.LessThanValidator,
+        [UIKeys.LESS_THAN_OR_EQUAL]: decoratorValidation.LessThanOrEqualValidator,
+        [UIKeys.GREATER_THAN]: decoratorValidation.GreaterThanValidator,
+        [UIKeys.GREATER_THAN_OR_EQUAL]: decoratorValidation.GreaterThanOrEqualValidator,
+    };
+    const HTML5DateFormat = "yyyy-MM-dd";
+    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",
+    };
+    const HTML5CheckTypes = [
+        HTML5InputTypes.CHECKBOX,
+        HTML5InputTypes.RADIO,
+    ];
+
+    class RenderingError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(RenderingError.name, msg);
+        }
+    }
+
+    /**
+     * @function formatByType
+     *
+     * @memberOf ui-decorators-web.ui
+     */
+    function formatByType(type, value, ...args) {
+        if (type === UIKeys.DATE) {
+            const format = args.shift() || HTML5DateFormat;
+            return decoratorValidation.formatDate(new Date(value), format);
+        }
+        return value;
+    }
+    function parseValueByType(type, value, fieldProps) {
+        let result = undefined;
+        switch (type) {
+            case HTML5InputTypes.NUMBER:
+                result = parseToNumber(value);
+                break;
+            case HTML5InputTypes.DATE: {
+                const format = fieldProps.format;
+                result =
+                    typeof value === decoratorValidation.ReservedModels.NUMBER
+                        ? new Date(value)
+                        : value
+                            ? format
+                                ? decoratorValidation.parseDate(format, value)
+                                : new Date(value)
+                            : undefined;
+                break;
+            }
+            default:
+                result =
+                    typeof value === decoratorValidation.ReservedModels.STRING
+                        ? escapeHtml(value)
+                        : result;
+        }
+        if (typeof result === "undefined") {
+            throw new dbDecorators.InternalError(`Failed to parse value of type ${type} from ${typeof value} - ${value}`);
+        }
+        return result;
+    }
+    function parseToNumber(value) {
+        if (typeof value === "number" && !isNaN(value))
+            return value;
+        const parsed = Number(value);
+        if (!isNaN(parsed))
+            return parsed;
+        return undefined;
+    }
+    function escapeHtml(value) {
+        if (!value)
+            return value;
+        const tagsToReplace = {
+            "&": "&",
+            "<": "&lt;",
+            ">": "&gt;",
+        };
+        return `${value}`.replace(/[&<>]/g, (tag) => {
+            return tagsToReplace[tag] || tag;
+        });
+    }
+    function revertHtml(value) {
+        const tagsToReplace = {
+            "&amp;": "&",
+            "&lt;": "<",
+            "&gt;": ">",
+        };
+        return `${value}`.replace(/&lt;|&gt;|&amp;/g, (tag) => {
+            return tagsToReplace[tag] || tag;
+        });
+    }
+    function generateUIModelID(model) {
+        let id;
+        try {
+            id = dbDecorators.findModelId(model);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            id = Date.now();
+        }
+        const name = model.constructor.name;
+        return `${name}-${id}`;
+    }
+
+    /**
+     * @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
+     */
+    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 decoratorValidation.ReservedModels.STRING:
+                        return HTML5InputTypes.TEXT;
+                    case decoratorValidation.ReservedModels.NUMBER:
+                    case decoratorValidation.ReservedModels.BIGINT:
+                        return HTML5InputTypes.NUMBER;
+                    case decoratorValidation.ReservedModels.BOOLEAN:
+                        return HTML5InputTypes.CHECKBOX;
+                    case decoratorValidation.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 decoratorValidation.ReservedModels.STRING;
+                    case HTML5InputTypes.NUMBER:
+                        return decoratorValidation.ReservedModels.NUMBER;
+                    case HTML5InputTypes.CHECKBOX:
+                        return decoratorValidation.ReservedModels.BOOLEAN;
+                    case HTML5InputTypes.DATE:
+                    case HTML5InputTypes.DATETIME_LOCAL:
+                    case HTML5InputTypes.TIME:
+                        return decoratorValidation.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
+                : Object.values(decoratorValidation.ComparisonValidationKeys).includes(key)
+                    ? value.propertyToCompare
+                    : 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), decoratorValidation.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.Reflection.getAllPropertyDecorators(model, UIKeys.REFLECT);
+            let children;
+            if (uiDecorators) {
+                const validationDecorators = reflection.Reflection.getAllPropertyDecorators(model, decoratorValidation.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:
+                            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 dbDecorators.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 dbDecorators.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 = decoratorValidation.Model.get(model.constructor.name);
+            if (!constructor)
+                throw new dbDecorators.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}`;
+        }
+    }
+
+    /**
+     * Tags the model as a uimodel, giving it the 'render' method
+     *
+     * @param {string} [tag] optional param. will render the provided elment wrapping the attribute uielements
+     * @param {{}} [props] optional param. Attributes to be passed to the tag element
+     * @param {function(any): void} [instanceCallback] optional callback returning the instance after creation for additional logic
+     *
+     * @decorator uimodel
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant System
+     *   participant uimodel
+     *   participant constructor
+     *   participant instance
+     *   System->>uimodel:do(constructor)
+     *   uimodel->>constructor: Executes the constructor
+     *   constructor->>uimodel: returns instance
+     *   uimodel->>instance: adds the render method
+     *   uimodel->>System: returns UIModel instance
+     *
+     * @category Decorators
+     */
+    function uimodel(tag, props) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return (original, propertyKey) => {
+            const meta = {
+                tag: tag || original.name,
+                props: props,
+            };
+            return reflection.metadata(RenderingEngine.key(UIKeys.UIMODEL), meta)(original);
+        };
+    }
+    function renderedBy(engine) {
+        return reflection.apply(reflection.metadata(RenderingEngine.key(UIKeys.RENDERED_BY), engine));
+    }
+
+    decoratorValidation.Model.prototype.render = function (...args) {
+        return RenderingEngine.render(this, ...args);
+    };
+
+    /**
+     * @namespace ui-decorators.ui.decorators
+     * @memberOf ui-decorators.ui
+     */
+    function hideOn(...operations) {
+        return decoratorValidation.propMetadata(RenderingEngine.key(UIKeys.HIDDEN), operations);
+    }
+    function hidden() {
+        return hideOn(dbDecorators.OperationKeys.CREATE, dbDecorators.OperationKeys.READ, dbDecorators.OperationKeys.UPDATE, dbDecorators.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
+     */
+    function uielement(tag, props, serialize = false) {
+        return (original, propertyKey) => {
+            const metadata = {
+                tag: tag,
+                serialize: serialize,
+                props: Object.assign({
+                    name: propertyKey,
+                }, props || {}),
+            };
+            return decoratorValidation.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
+     */
+    function uiprop(propName = undefined, stringify = false) {
+        return (target, propertyKey) => {
+            const metadata = {
+                name: propName || propertyKey,
+                stringify: stringify,
+            };
+            decoratorValidation.propMetadata(RenderingEngine.key(UIKeys.PROP), metadata)(target, propertyKey);
+        };
+    }
+
+    /**
+     * @module ui-decorators
+     */
+    /**
+     * @summary stores the current package version
+     * @description this is how you should document a constant
+     * @const VERSION
+     * @memberOf module:ui-decorators
+     */
+    const VERSION = "##VERSION##";
+
+    exports.HTML5CheckTypes = HTML5CheckTypes;
+    exports.HTML5DateFormat = HTML5DateFormat;
+    exports.HTML5InputTypes = HTML5InputTypes;
+    exports.RenderingEngine = RenderingEngine;
+    exports.RenderingError = RenderingError;
+    exports.UIKeys = UIKeys;
+    exports.VERSION = VERSION;
+    exports.ValidatableByAttribute = ValidatableByAttribute;
+    exports.ValidatableByType = ValidatableByType;
+    exports.escapeHtml = escapeHtml;
+    exports.formatByType = formatByType;
+    exports.generateUIModelID = generateUIModelID;
+    exports.hidden = hidden;
+    exports.hideOn = hideOn;
+    exports.parseToNumber = parseToNumber;
+    exports.parseValueByType = parseValueByType;
+    exports.renderedBy = renderedBy;
+    exports.revertHtml = revertHtml;
+    exports.uielement = uielement;
+    exports.uimodel = uimodel;
+    exports.uiprop = uiprop;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ui-decorators.cjs","sources":["../src/ui/constants.ts","../src/ui/errors.ts","../src/ui/utils.ts","../src/ui/Rendering.ts","../src/model/decorators.ts","../src/model/overrides.ts","../src/ui/decorators.ts","../src/index.ts"],"sourcesContent":["import {\n  Constructor,\n  DateValidator,\n  DiffValidator,\n  EmailValidator,\n  EqualsValidator,\n  GreaterThanOrEqualValidator,\n  GreaterThanValidator,\n  LessThanOrEqualValidator,\n  LessThanValidator,\n  MaxLengthValidator,\n  MaxValidator,\n  MinLengthValidator,\n  MinValidator,\n  ModelKeys,\n  PasswordValidator,\n  PatternValidator,\n  RequiredValidator,\n  StepValidator,\n  URLValidator,\n  ValidationKeys,\n  Validator,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @enum UIKeys\n * @category Constants\n */\nexport const UIKeys = {\n  REFLECT: `${ModelKeys.REFLECT}.ui.`,\n  UIMODEL: \"uimodel\",\n  RENDERED_BY: \"rendered-by\",\n  ELEMENT: \"element\",\n  PROP: \"prop\",\n  NAME: \"name\",\n  NAME_PREFIX: \"input-\",\n  CUSTOM_PROPS: \"customValidationProps\",\n\n  TYPE: \"type\",\n  SUB_TYPE: \"subtype\",\n\n  HIDDEN: \"hidden\",\n  FORMAT: \"format\",\n\n  READ_ONLY: \"readonly\",\n  REQUIRED: ValidationKeys.REQUIRED,\n  MIN: ValidationKeys.MIN,\n  MIN_LENGTH: ValidationKeys.MIN_LENGTH,\n  MAX: ValidationKeys.MAX,\n  MAX_LENGTH: ValidationKeys.MAX_LENGTH,\n  PATTERN: ValidationKeys.PATTERN,\n  URL: ValidationKeys.URL,\n  STEP: ValidationKeys.STEP,\n  DATE: ValidationKeys.DATE,\n  EMAIL: ValidationKeys.EMAIL,\n  PASSWORD: ValidationKeys.PASSWORD,\n  EQUALS: ValidationKeys.EQUALS,\n  DIFF: ValidationKeys.DIFF,\n  LESS_THAN: ValidationKeys.LESS_THAN,\n  LESS_THAN_OR_EQUAL: ValidationKeys.LESS_THAN_OR_EQUAL,\n  GREATER_THAN: ValidationKeys.GREATER_THAN,\n  GREATER_THAN_OR_EQUAL: ValidationKeys.GREATER_THAN_OR_EQUAL,\n};\n\nexport const ValidatableByType: Record<string, Constructor<Validator>> = {\n  [UIKeys.EMAIL]: EmailValidator,\n  [UIKeys.URL]: URLValidator,\n  [UIKeys.DATE]: DateValidator,\n  [UIKeys.PASSWORD]: PasswordValidator,\n};\n\n/**\n * @constant ValidatableByAttribute\n *\n * @memberOf ui-decorators-web.ui\n */\nexport const ValidatableByAttribute: Record<string, Constructor<Validator>> = {\n  [UIKeys.REQUIRED]: RequiredValidator,\n  [UIKeys.MIN]: MinValidator,\n  [UIKeys.MAX]: MaxValidator,\n  [UIKeys.STEP]: StepValidator,\n  [UIKeys.MIN_LENGTH]: MinLengthValidator,\n  [UIKeys.MAX_LENGTH]: MaxLengthValidator,\n  [UIKeys.PATTERN]: PatternValidator,\n  [UIKeys.EQUALS]: EqualsValidator,\n  [UIKeys.DIFF]: DiffValidator,\n  [UIKeys.LESS_THAN]: LessThanValidator,\n  [UIKeys.LESS_THAN_OR_EQUAL]: LessThanOrEqualValidator,\n  [UIKeys.GREATER_THAN]: GreaterThanValidator,\n  [UIKeys.GREATER_THAN_OR_EQUAL]: GreaterThanOrEqualValidator,\n};\n\nexport const HTML5DateFormat = \"yyyy-MM-dd\";\n\nexport const HTML5InputTypes = {\n  BUTTON: \"button\",\n  CHECKBOX: \"checkbox\",\n  COLOR: \"color\",\n  DATE: UIKeys.DATE,\n  DATETIME_LOCAL: \"datetime-local\",\n  EMAIL: UIKeys.EMAIL,\n  FILE: \"file\",\n  HIDDEN: \"hidden\",\n  IMAGE: \"image\",\n  MONTH: \"month\",\n  NUMBER: \"number\",\n  PASSWORD: UIKeys.PASSWORD,\n  RADIO: \"radio\",\n  RANGE: \"range\",\n  RESET: \"reset\",\n  SEARCH: \"search\",\n  SUBMIT: \"submit\",\n  TEL: \"tel\",\n  TEXT: \"text\",\n  TIME: \"time\",\n  URL: UIKeys.URL,\n  WEEK: \"week\",\n};\n\nexport const HTML5CheckTypes = [\n  HTML5InputTypes.CHECKBOX,\n  HTML5InputTypes.RADIO,\n];\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class RenderingError extends BaseError {\n  constructor(msg: string | Error) {\n    super(RenderingError.name, msg);\n  }\n}\n","import {\n  formatDate,\n  Model,\n  parseDate,\n  ReservedModels,\n} from \"@decaf-ts/decorator-validation\";\nimport { HTML5DateFormat, HTML5InputTypes, UIKeys } from \"./constants\";\nimport { findModelId, InternalError } from \"@decaf-ts/db-decorators\";\nimport { FieldProperties } from \"./types\";\n\n/**\n * @function formatByType\n *\n * @memberOf ui-decorators-web.ui\n */\nexport function formatByType(\n  type: any,\n  value: any,\n  ...args: unknown[]\n): string | number {\n  if (type === UIKeys.DATE) {\n    const format: string = (args.shift() as string) || HTML5DateFormat;\n    return formatDate(new Date(value), format);\n  }\n  return value;\n}\n\nexport function parseValueByType(\n  type: string,\n  value: string | number,\n  fieldProps: FieldProperties\n): string | number | Date {\n  let result: string | number | Date | undefined = undefined;\n  switch (type) {\n    case HTML5InputTypes.NUMBER:\n      result = parseToNumber(value);\n      break;\n    case HTML5InputTypes.DATE: {\n      const format: string | undefined = fieldProps.format;\n      result =\n        typeof value === ReservedModels.NUMBER\n          ? new Date(value)\n          : value\n            ? format\n              ? parseDate(format, value)\n              : new Date(value)\n            : undefined;\n      break;\n    }\n    default:\n      result =\n        typeof value === ReservedModels.STRING\n          ? escapeHtml(value as string)\n          : result;\n  }\n  if (typeof result === \"undefined\") {\n    throw new InternalError(\n      `Failed to parse value of type ${type} from ${typeof value} - ${value}`\n    );\n  }\n  return result;\n}\n\nexport function parseToNumber(value: string | number) {\n  if (typeof value === \"number\" && !isNaN(value)) return value;\n\n  const parsed = Number(value);\n  if (!isNaN(parsed)) return parsed;\n\n  return undefined;\n}\n\nexport function escapeHtml(value: string) {\n  if (!value) \n    return value;\n\n  const tagsToReplace: Record<string, string> = {\n    \"&\": \"&amp;\",\n    \"<\": \"&lt;\",\n    \">\": \"&gt;\",\n  };\n  return `${value}`.replace(/[&<>]/g, (tag) => {\n    return tagsToReplace[tag] || tag;\n  });\n}\n\nexport function revertHtml(value: string) {\n  const tagsToReplace: Record<string, string> = {\n    \"&amp;\": \"&\",\n    \"&lt;\": \"<\",\n    \"&gt;\": \">\",\n  };\n\n  return `${value}`.replace(/&lt;|&gt;|&amp;/g, (tag) => {\n    return tagsToReplace[tag] || tag;\n  });\n}\n\nexport function generateUIModelID<M extends Model>(model: M) {\n  let id: string | number;\n  try {\n    id = findModelId(model);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    id = Date.now();\n  }\n  const name = model.constructor.name;\n  return `${name}-${id}`;\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\nimport {\n  ComparisonValidationKeys,\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\n      ? true\n      : Object.values(ComparisonValidationKeys).includes(key as any)\n        ? value.propertyToCompare\n        : 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","import { UIKeys } from \"../ui/constants\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { RenderingEngine } from \"../ui/Rendering\";\nimport { UIModelMetadata } from \"../ui/types\";\n\n/**\n * Tags the model as a uimodel, giving it the 'render' method\n *\n * @param {string} [tag] optional param. will render the provided elment wrapping the attribute uielements\n * @param {{}} [props] optional param. Attributes to be passed to the tag element\n * @param {function(any): void} [instanceCallback] optional callback returning the instance after creation for additional logic\n *\n * @decorator uimodel\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uimodel\n *   participant constructor\n *   participant instance\n *   System->>uimodel:do(constructor)\n *   uimodel->>constructor: Executes the constructor\n *   constructor->>uimodel: returns instance\n *   uimodel->>instance: adds the render method\n *   uimodel->>System: returns UIModel instance\n *\n * @category Decorators\n */\nexport function uimodel(tag?: string, props?: Record<string, any>) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  return (original: any, propertyKey?: any) => {\n    const meta: UIModelMetadata = {\n      tag: tag || original.name,\n      props: props,\n    };\n    return metadata(RenderingEngine.key(UIKeys.UIMODEL), meta)(original);\n  };\n}\n\nexport function renderedBy(engine: string) {\n  return apply(metadata(RenderingEngine.key(UIKeys.RENDERED_BY), engine));\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { RenderingEngine } from \"../ui/Rendering\";\n\nModel.prototype.render = function <M extends Model>(this: M, ...args: any[]) {\n  return RenderingEngine.render(this, ...args);\n};\n","import \"reflect-metadata\";\nimport { UIKeys } from \"./constants\";\nimport { propMetadata } from \"@decaf-ts/decorator-validation\";\nimport { CrudOperationKeys, UIElementMetadata, UIPropMetadata } from \"./types\";\nimport { RenderingEngine } from \"./Rendering\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @namespace ui-decorators.ui.decorators\n * @memberOf ui-decorators.ui\n */\n\nexport function hideOn(...operations: CrudOperationKeys[]) {\n  return propMetadata<CrudOperationKeys[]>(\n    RenderingEngine.key(UIKeys.HIDDEN),\n    operations\n  );\n}\n\nexport function hidden() {\n  return hideOn(\n    OperationKeys.CREATE,\n    OperationKeys.READ,\n    OperationKeys.UPDATE,\n    OperationKeys.DELETE\n  );\n}\n\n/**\n * Adds the UIElement definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}\n *\n * @param {string} tag The component/HTML element tag name\n * @param {{}} [props] The properties to pass to that component/HTML Element\n * @param serialize\n *\n * @decorator uielement\n *\n * @category Decorators\n * @subcategory ui-decorators\n */\nexport function uielement(\n  tag: string,\n  props?: Record<string, any>,\n  serialize: boolean = false\n) {\n  return (original: any, propertyKey?: any) => {\n    const metadata: UIElementMetadata = {\n      tag: tag,\n      serialize: serialize,\n      props: Object.assign(\n        {\n          name: propertyKey,\n        },\n        props || {}\n      ),\n    };\n\n    return propMetadata(RenderingEngine.key(UIKeys.ELEMENT), metadata)(\n      original,\n      propertyKey\n    );\n  };\n}\n\n/**\n * Adds the UIProp definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}\n *\n * this requires a '@uimodel' with a defined tag\n *\n * @param {string} [propName] the property name that will be passed to the component. defaults to the PropertyKey\n *\n * @decorator uiprop\n *\n * @category Decorators\n * @subcategory ui-decorators\n */\nexport function uiprop(\n  propName: string | undefined = undefined,\n  stringify: boolean = false\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: UIPropMetadata = {\n      name: propName || propertyKey,\n      stringify: stringify,\n    };\n    propMetadata(RenderingEngine.key(UIKeys.PROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n","/**\n * @module ui-decorators\n */\n\nexport * from \"./model\";\nexport * from \"./ui\";\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ui-decorators\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["ModelKeys","ValidationKeys","EmailValidator","URLValidator","DateValidator","PasswordValidator","RequiredValidator","MinValidator","MaxValidator","StepValidator","MinLengthValidator","MaxLengthValidator","PatternValidator","EqualsValidator","DiffValidator","LessThanValidator","LessThanOrEqualValidator","GreaterThanValidator","GreaterThanOrEqualValidator","BaseError","formatDate","ReservedModels","parseDate","InternalError","findModelId","ComparisonValidationKeys","Model","Reflection","metadata","apply","propMetadata","OperationKeys"],"mappings":"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"}