@decaf-ts/ui-decorators 0.5.15 → 0.5.16

package/lib/ui/decorators.cjs

@@ -6,6 +6,7 @@ exports.uielement = uielement;
 exports.uiprop = uiprop;
 exports.uichild = uichild;
 exports.uilistprop = uilistprop;
+exports.uilayoutitem = uilayoutitem;
 require("reflect-metadata");
 const constants_1 = require("./constants.cjs");
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
@@ -316,4 +317,64 @@ function uilistprop(propName = undefined, props) {
         (0, decorator_validation_1.propMetadata)(Rendering_1.RenderingEngine.key(constants_1.UIKeys.UILISTPROP), metadata)(target, propertyKey);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/ui/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import \"reflect-metadata\";\nimport { UIKeys } from \"./constants\";\nimport { propMetadata } from \"@decaf-ts/decorator-validation\";\nimport {\n  CrudOperationKeys,\n  UIElementMetadata,\n  UIListPropMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { RenderingEngine } from \"./Rendering\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Decorator that hides a property during specific CRUD operations\n * @summary Controls property visibility based on operation type\n * This decorator allows you to specify which CRUD operations should hide a property\n * in the UI. The property will only be visible during operations not specified.\n *\n * @param operations - The CRUD operations during which the property should be hidden\n * @return {Function} A property decorator function\n *\n * @function hideOn\n * @category Property Decorators\n *\n * @example\n * // Hide the password field during READ operations\n * class User {\n *   @attribute()\n *   username: string;\n *\n *   @attribute()\n *   @hideOn(OperationKeys.READ)\n *   password: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant hideOn\n *   participant RenderingEngine\n *   participant UI\n *   Model->>hideOn: Apply to property\n *   hideOn->>Model: Add hidden metadata\n *   RenderingEngine->>Model: Check if property should be hidden\n *   Model->>RenderingEngine: Return hidden operations\n *   RenderingEngine->>UI: Render or hide based on current operation\n */\nexport function hideOn(...operations: CrudOperationKeys[]) {\n  return propMetadata<CrudOperationKeys[]>(\n    RenderingEngine.key(UIKeys.HIDDEN),\n    operations\n  );\n}\n\n/**\n * @description Decorator that completely hides a property in all UI operations\n * @summary Makes a property invisible in all CRUD operations\n * This decorator is a convenience wrapper around hideOn that hides a property\n * during all CRUD operations (CREATE, READ, UPDATE, DELETE).\n *\n * @return {Function} A property decorator function\n *\n * @function hidden\n * @category Property Decorators\n *\n * @example\n * // Completely hide the internalId field in the UI\n * class Product {\n *   @attribute()\n *   name: string;\n *\n *   @attribute()\n *   @hidden()\n *   internalId: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant hidden\n *   participant hideOn\n *   participant RenderingEngine\n *   Model->>hidden: Apply to property\n *   hidden->>hideOn: Call with all operations\n *   hideOn->>Model: Add hidden metadata\n *   RenderingEngine->>Model: Check if property should be hidden\n *   Model->>RenderingEngine: Return all operations\n *   RenderingEngine->>UI: Always hide property\n */\nexport function hidden() {\n  return hideOn(\n    OperationKeys.CREATE,\n    OperationKeys.READ,\n    OperationKeys.UPDATE,\n    OperationKeys.DELETE\n  );\n}\n\n/**\n * @description Decorator that specifies how a property should be rendered as a UI element\n * @summary Maps a model property to a specific UI element with custom properties\n * This decorator allows you to define which HTML element or component should be used\n * to render a specific property, along with any additional properties to pass to that element.\n *\n * @param {string} tag The HTML element or component tag name to use for rendering\n * @param {Record<string, any>} [props] Additional properties to pass to the element\n * @param {boolean} [serialize=false] Whether the property should be serialized\n * @return {Function} A property decorator function\n *\n * @function uielement\n * @category Property Decorators\n *\n * @example\n * // Render a property as a text input\n * class LoginForm {\n *   @attribute()\n *   @uielement('input', { type: 'text', placeholder: 'Enter username' })\n *   username: string;\n *\n *   @attribute()\n *   @uielement('input', { type: 'password', placeholder: 'Enter password' })\n *   password: string;\n *\n *   @attribute()\n *   @uielement('button', { class: 'btn-primary' })\n *   submit: string = 'Login';\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uielement\n *   participant RenderingEngine\n *   participant UI\n *   Model->>uielement: Apply to property\n *   uielement->>Model: Add element metadata\n *   RenderingEngine->>Model: Get element metadata\n *   Model->>RenderingEngine: Return tag and props\n *   RenderingEngine->>UI: Render with specified element\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({}, props || {}, {\n        name: propertyKey,\n      }),\n    };\n\n    return propMetadata(RenderingEngine.key(UIKeys.ELEMENT), metadata)(\n      original,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that maps a model property to a UI component property\n * @summary Specifies how a property should be passed to a UI component\n * This decorator allows you to define how a model property should be mapped to\n * a property of the UI component when rendering. It requires the class to be\n * decorated with @uimodel.\n *\n * @param {string} [propName] The name of the property to pass to the component (defaults to the property key)\n * @param {boolean} [stringify=false] Whether to stringify the property value\n * @return {Function} A property decorator function\n *\n * @function uiprop\n * @category Property Decorators\n *\n * @example\n * // Map model properties to component properties\n * @uimodel('user-profile')\n * class UserProfile {\n *   @attribute()\n *   @uiprop() // Will be passed as 'fullName' to the component\n *   fullName: string;\n *\n *   @attribute()\n *   @uiprop('userEmail') // Will be passed as 'userEmail' to the component\n *   email: string;\n *\n *   @attribute()\n *   @uiprop('userData', true) // Will be passed as stringified JSON\n *   userData: Record<string, any>;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uiprop\n *   participant RenderingEngine\n *   participant Component\n *   Model->>uiprop: Apply to property\n *   uiprop->>Model: Add prop metadata\n *   RenderingEngine->>Model: Get prop metadata\n *   Model->>RenderingEngine: Return prop name and stringify flag\n *   RenderingEngine->>Component: Pass property with specified name\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/**\n * @description Decorator that maps a nested model property to a UI component property.\n * @summary Defines how a parent component should render the child model when nested.\n *\n * This decorator is used to decorate properties that are nested models.\n * When applied, it allows overriding the default tag of the child model with the provided one,\n * enabling different rendering behavior when the model acts as a child (nested)\n * compared to when it is rendered as the parent model.\n *\n * It requires the class to be decorated with `@uimodel`.\n *\n * @param {string} clazz The model class name to pass to the component (defaults to the property key).\n * @param {string} tag The HTML element or component tag name to override the UI tag of the nested model\n * @param {Record<string, any>} [props] Additional properties to pass to the element\n * @param {boolean} [serialize=false] Whether the property should be serialized\n * @return {Function} A property decorator function.\n *\n * @function uichild\n * @category Property Decorators\n *\n * @example\n * // Map a nested model to a component property with a different tag when nested\n * @uimodel('address-component')\n * class Address {\n *   @attribute()\n *   street: string;\n *\n *   @attribute()\n *   city: string;\n * }\n *\n * @uimodel('user-profile')\n * class UserProfile {\n *   @attribute()\n *   @uichild(Address.name, 'address-child-component')\n *   address: Address;\n * }\n *\n * // In this example, the Address model has the default tag 'address-component' when rendered as a root component,\n * // but when used inside UserProfile, it is rendered with the overridden tag 'address-child-component'\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uichild\n *   participant RenderingEngine\n *   participant Component\n *   Model->>uichild: Apply to property\n *   uichild->>Model: Add child metadata\n *   RenderingEngine->>Model: Get child metadata\n *   Model->>RenderingEngine: Return prop name, stringify flag, and child tag override\n *   RenderingEngine->>Component: Pass property with specified name and render with overridden tag if nested\n */\n\nexport function uichild(\n  clazz: string,\n  tag: string,\n  props: Record<string, any> = {},\n  serialize: boolean = false\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: UIElementMetadata = {\n      tag: tag,\n      serialize: serialize,\n      props: Object.assign({}, props || {}, {\n        name: clazz || propertyKey,\n      }),\n    };\n\n    propMetadata(RenderingEngine.key(UIKeys.CHILD), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that maps a model property to a list item component\n * @summary Specifies how a property should be rendered in a list context\n * This decorator allows you to define how a model property containing a list\n * should be rendered. It requires the class to be decorated with @uilistitem.\n *\n * @param {string} [propName] The name of the property to pass to the list component (defaults to the property key)\n * @param {Record<string, any>} [props] Additional properties to pass to the list container\n * @return {Function} A property decorator function\n *\n * @function uilistprop\n * @category Property Decorators\n *\n * @example\n * // Define a list property with custom rendering\n * @uimodel('todo-list')\n * class TodoList {\n *   @attribute()\n *   title: string;\n *\n *   @attribute()\n *   @uilistprop('items', { class: 'todo-items-container' })\n *   items: TodoItem[];\n * }\n *\n * @uilistitem('li', { class: 'todo-item' })\n * class TodoItem extends Model {\n *   @attribute()\n *   text: string;\n *\n *   @attribute()\n *   completed: boolean;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uilistprop\n *   participant RenderingEngine\n *   participant ListContainer\n *   participant ListItems\n *   Model->>uilistprop: Apply to property\n *   uilistprop->>Model: Add list prop metadata\n *   RenderingEngine->>Model: Get list prop metadata\n *   Model->>RenderingEngine: Return prop name and container props\n *   RenderingEngine->>ListContainer: Create container with props\n *   RenderingEngine->>ListItems: Render each item using @uilistitem\n *   ListContainer->>RenderingEngine: Return rendered list\n */\nexport function uilistprop(\n  propName: string | undefined = undefined,\n  props?: Record<string, any>\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: Partial<UIListPropMetadata> = {\n      name: propName || propertyKey,\n      props: props || {},\n    };\n    propMetadata(RenderingEngine.key(UIKeys.UILISTPROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n"]}
+/**
+ * @description Decorator that positions a property in a specific grid layout position
+ * @summary Specifies the column and row position for a property in a UI layout grid
+ * This decorator allows you to define the specific position of a property within
+ * a grid-based layout system. It specifies which column and row the property
+ * should occupy when rendered in the UI.
+ *
+ * @param {number} col The column position in the grid layout
+ * @param {number} [row=1] The row position in the grid layout (defaults to 1)
+ * @param {Record<string, any>} [props={}] Additional properties to pass to the layout item
+ * @return {Function} A property decorator function
+ *
+ * @function uilayoutitem
+ * @category Property Decorators
+ *
+ * @example
+ * // Position properties in a grid layout
+ * @uimodel('user-form')
+ * class UserForm {
+ *   @attribute()
+ *   @uilayoutitem(1, 1) // First column, first row
+ *   firstName: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(2, 1) // Second column, first row
+ *   lastName: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(1, 2, { colspan: 2 }) // First column, second row, spans 2 columns
+ *   email: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(1, 3, { class: 'full-width' }) // First column, third row with custom class
+ *   bio: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uilayoutitem
+ *   participant RenderingEngine
+ *   participant LayoutContainer
+ *   Model->>uilayoutitem: Apply to property
+ *   uilayoutitem->>Model: Add layout item metadata
+ *   RenderingEngine->>Model: Get layout item metadata
+ *   Model->>RenderingEngine: Return column, row, and props
+ *   RenderingEngine->>LayoutContainer: Position element at grid coordinates
+ *   LayoutContainer->>RenderingEngine: Return positioned element
+ */
+function uilayoutitem(col, row = 1, props = {}) {
+    return (target, propertyKey) => {
+        const metadata = {
+            name: propertyKey,
+            col,
+            row,
+            props: Object.assign({}, props),
+        };
+        (0, decorator_validation_1.propMetadata)(Rendering_1.RenderingEngine.key(constants_1.UIKeys.UILAYOUTITEM), metadata)(target, propertyKey);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/ui/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import \"reflect-metadata\";\nimport { UIKeys } from \"./constants\";\nimport { propMetadata } from \"@decaf-ts/decorator-validation\";\nimport {\n  CrudOperationKeys,\n  UIElementMetadata,\n  UILayoutItemMetadata,\n  UIListPropMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { RenderingEngine } from \"./Rendering\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Decorator that hides a property during specific CRUD operations\n * @summary Controls property visibility based on operation type\n * This decorator allows you to specify which CRUD operations should hide a property\n * in the UI. The property will only be visible during operations not specified.\n *\n * @param operations - The CRUD operations during which the property should be hidden\n * @return {Function} A property decorator function\n *\n * @function hideOn\n * @category Property Decorators\n *\n * @example\n * // Hide the password field during READ operations\n * class User {\n *   @attribute()\n *   username: string;\n *\n *   @attribute()\n *   @hideOn(OperationKeys.READ)\n *   password: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant hideOn\n *   participant RenderingEngine\n *   participant UI\n *   Model->>hideOn: Apply to property\n *   hideOn->>Model: Add hidden metadata\n *   RenderingEngine->>Model: Check if property should be hidden\n *   Model->>RenderingEngine: Return hidden operations\n *   RenderingEngine->>UI: Render or hide based on current operation\n */\nexport function hideOn(...operations: CrudOperationKeys[]) {\n  return propMetadata<CrudOperationKeys[]>(\n    RenderingEngine.key(UIKeys.HIDDEN),\n    operations\n  );\n}\n\n/**\n * @description Decorator that completely hides a property in all UI operations\n * @summary Makes a property invisible in all CRUD operations\n * This decorator is a convenience wrapper around hideOn that hides a property\n * during all CRUD operations (CREATE, READ, UPDATE, DELETE).\n *\n * @return {Function} A property decorator function\n *\n * @function hidden\n * @category Property Decorators\n *\n * @example\n * // Completely hide the internalId field in the UI\n * class Product {\n *   @attribute()\n *   name: string;\n *\n *   @attribute()\n *   @hidden()\n *   internalId: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant hidden\n *   participant hideOn\n *   participant RenderingEngine\n *   Model->>hidden: Apply to property\n *   hidden->>hideOn: Call with all operations\n *   hideOn->>Model: Add hidden metadata\n *   RenderingEngine->>Model: Check if property should be hidden\n *   Model->>RenderingEngine: Return all operations\n *   RenderingEngine->>UI: Always hide property\n */\nexport function hidden() {\n  return hideOn(\n    OperationKeys.CREATE,\n    OperationKeys.READ,\n    OperationKeys.UPDATE,\n    OperationKeys.DELETE\n  );\n}\n\n/**\n * @description Decorator that specifies how a property should be rendered as a UI element\n * @summary Maps a model property to a specific UI element with custom properties\n * This decorator allows you to define which HTML element or component should be used\n * to render a specific property, along with any additional properties to pass to that element.\n *\n * @param {string} tag The HTML element or component tag name to use for rendering\n * @param {Record<string, any>} [props] Additional properties to pass to the element\n * @param {boolean} [serialize=false] Whether the property should be serialized\n * @return {Function} A property decorator function\n *\n * @function uielement\n * @category Property Decorators\n *\n * @example\n * // Render a property as a text input\n * class LoginForm {\n *   @attribute()\n *   @uielement('input', { type: 'text', placeholder: 'Enter username' })\n *   username: string;\n *\n *   @attribute()\n *   @uielement('input', { type: 'password', placeholder: 'Enter password' })\n *   password: string;\n *\n *   @attribute()\n *   @uielement('button', { class: 'btn-primary' })\n *   submit: string = 'Login';\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uielement\n *   participant RenderingEngine\n *   participant UI\n *   Model->>uielement: Apply to property\n *   uielement->>Model: Add element metadata\n *   RenderingEngine->>Model: Get element metadata\n *   Model->>RenderingEngine: Return tag and props\n *   RenderingEngine->>UI: Render with specified element\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({}, props || {}, {\n        name: propertyKey,\n      }),\n    };\n\n    return propMetadata(RenderingEngine.key(UIKeys.ELEMENT), metadata)(\n      original,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that maps a model property to a UI component property\n * @summary Specifies how a property should be passed to a UI component\n * This decorator allows you to define how a model property should be mapped to\n * a property of the UI component when rendering. It requires the class to be\n * decorated with @uimodel.\n *\n * @param {string} [propName] The name of the property to pass to the component (defaults to the property key)\n * @param {boolean} [stringify=false] Whether to stringify the property value\n * @return {Function} A property decorator function\n *\n * @function uiprop\n * @category Property Decorators\n *\n * @example\n * // Map model properties to component properties\n * @uimodel('user-profile')\n * class UserProfile {\n *   @attribute()\n *   @uiprop() // Will be passed as 'fullName' to the component\n *   fullName: string;\n *\n *   @attribute()\n *   @uiprop('userEmail') // Will be passed as 'userEmail' to the component\n *   email: string;\n *\n *   @attribute()\n *   @uiprop('userData', true) // Will be passed as stringified JSON\n *   userData: Record<string, any>;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uiprop\n *   participant RenderingEngine\n *   participant Component\n *   Model->>uiprop: Apply to property\n *   uiprop->>Model: Add prop metadata\n *   RenderingEngine->>Model: Get prop metadata\n *   Model->>RenderingEngine: Return prop name and stringify flag\n *   RenderingEngine->>Component: Pass property with specified name\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/**\n * @description Decorator that maps a nested model property to a UI component property.\n * @summary Defines how a parent component should render the child model when nested.\n *\n * This decorator is used to decorate properties that are nested models.\n * When applied, it allows overriding the default tag of the child model with the provided one,\n * enabling different rendering behavior when the model acts as a child (nested)\n * compared to when it is rendered as the parent model.\n *\n * It requires the class to be decorated with `@uimodel`.\n *\n * @param {string} clazz The model class name to pass to the component (defaults to the property key).\n * @param {string} tag The HTML element or component tag name to override the UI tag of the nested model\n * @param {Record<string, any>} [props] Additional properties to pass to the element\n * @param {boolean} [serialize=false] Whether the property should be serialized\n * @return {Function} A property decorator function.\n *\n * @function uichild\n * @category Property Decorators\n *\n * @example\n * // Map a nested model to a component property with a different tag when nested\n * @uimodel('address-component')\n * class Address {\n *   @attribute()\n *   street: string;\n *\n *   @attribute()\n *   city: string;\n * }\n *\n * @uimodel('user-profile')\n * class UserProfile {\n *   @attribute()\n *   @uichild(Address.name, 'address-child-component')\n *   address: Address;\n * }\n *\n * // In this example, the Address model has the default tag 'address-component' when rendered as a root component,\n * // but when used inside UserProfile, it is rendered with the overridden tag 'address-child-component'\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uichild\n *   participant RenderingEngine\n *   participant Component\n *   Model->>uichild: Apply to property\n *   uichild->>Model: Add child metadata\n *   RenderingEngine->>Model: Get child metadata\n *   Model->>RenderingEngine: Return prop name, stringify flag, and child tag override\n *   RenderingEngine->>Component: Pass property with specified name and render with overridden tag if nested\n */\n\nexport function uichild(\n  clazz: string,\n  tag: string,\n  props: Record<string, any> = {},\n  serialize: boolean = false\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: UIElementMetadata = {\n      tag: tag,\n      serialize: serialize,\n      props: Object.assign({}, props || {}, {\n        name: clazz || propertyKey,\n      }),\n    };\n\n    propMetadata(RenderingEngine.key(UIKeys.CHILD), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that maps a model property to a list item component\n * @summary Specifies how a property should be rendered in a list context\n * This decorator allows you to define how a model property containing a list\n * should be rendered. It requires the class to be decorated with @uilistitem.\n *\n * @param {string} [propName] The name of the property to pass to the list component (defaults to the property key)\n * @param {Record<string, any>} [props] Additional properties to pass to the list container\n * @return {Function} A property decorator function\n *\n * @function uilistprop\n * @category Property Decorators\n *\n * @example\n * // Define a list property with custom rendering\n * @uimodel('todo-list')\n * class TodoList {\n *   @attribute()\n *   title: string;\n *\n *   @attribute()\n *   @uilistprop('items', { class: 'todo-items-container' })\n *   items: TodoItem[];\n * }\n *\n * @uilistitem('li', { class: 'todo-item' })\n * class TodoItem extends Model {\n *   @attribute()\n *   text: string;\n *\n *   @attribute()\n *   completed: boolean;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uilistprop\n *   participant RenderingEngine\n *   participant ListContainer\n *   participant ListItems\n *   Model->>uilistprop: Apply to property\n *   uilistprop->>Model: Add list prop metadata\n *   RenderingEngine->>Model: Get list prop metadata\n *   Model->>RenderingEngine: Return prop name and container props\n *   RenderingEngine->>ListContainer: Create container with props\n *   RenderingEngine->>ListItems: Render each item using @uilistitem\n *   ListContainer->>RenderingEngine: Return rendered list\n */\nexport function uilistprop(\n  propName: string | undefined = undefined,\n  props?: Record<string, any>\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: Partial<UIListPropMetadata> = {\n      name: propName || propertyKey,\n      props: props || {},\n    };\n    propMetadata(RenderingEngine.key(UIKeys.UILISTPROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that positions a property in a specific grid layout position\n * @summary Specifies the column and row position for a property in a UI layout grid\n * This decorator allows you to define the specific position of a property within\n * a grid-based layout system. It specifies which column and row the property\n * should occupy when rendered in the UI.\n *\n * @param {number} col The column position in the grid layout\n * @param {number} [row=1] The row position in the grid layout (defaults to 1)\n * @param {Record<string, any>} [props={}] Additional properties to pass to the layout item\n * @return {Function} A property decorator function\n *\n * @function uilayoutitem\n * @category Property Decorators\n *\n * @example\n * // Position properties in a grid layout\n * @uimodel('user-form')\n * class UserForm {\n *   @attribute()\n *   @uilayoutitem(1, 1) // First column, first row\n *   firstName: string;\n *\n *   @attribute()\n *   @uilayoutitem(2, 1) // Second column, first row\n *   lastName: string;\n *\n *   @attribute()\n *   @uilayoutitem(1, 2, { colspan: 2 }) // First column, second row, spans 2 columns\n *   email: string;\n *\n *   @attribute()\n *   @uilayoutitem(1, 3, { class: 'full-width' }) // First column, third row with custom class\n *   bio: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uilayoutitem\n *   participant RenderingEngine\n *   participant LayoutContainer\n *   Model->>uilayoutitem: Apply to property\n *   uilayoutitem->>Model: Add layout item metadata\n *   RenderingEngine->>Model: Get layout item metadata\n *   Model->>RenderingEngine: Return column, row, and props\n *   RenderingEngine->>LayoutContainer: Position element at grid coordinates\n *   LayoutContainer->>RenderingEngine: Return positioned element\n */\nexport function uilayoutitem(\n  col: number,\n  row: number = 1,\n  props: Record<string, any> = {},\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: UILayoutItemMetadata = {\n      name:  propertyKey,\n      col,\n      row,\n      props: Object.assign({}, props),\n    };  \n    propMetadata(RenderingEngine.key(UIKeys.UILAYOUTITEM), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n"]}

package/lib/ui/decorators.d.ts

@@ -263,3 +263,53 @@ export declare function uichild(clazz: string, tag: string, props?: Record<strin
  *   ListContainer->>RenderingEngine: Return rendered list
  */
 export declare function uilistprop(propName?: string | undefined, props?: Record<string, any>): (target: any, propertyKey: string) => void;
+/**
+ * @description Decorator that positions a property in a specific grid layout position
+ * @summary Specifies the column and row position for a property in a UI layout grid
+ * This decorator allows you to define the specific position of a property within
+ * a grid-based layout system. It specifies which column and row the property
+ * should occupy when rendered in the UI.
+ *
+ * @param {number} col The column position in the grid layout
+ * @param {number} [row=1] The row position in the grid layout (defaults to 1)
+ * @param {Record<string, any>} [props={}] Additional properties to pass to the layout item
+ * @return {Function} A property decorator function
+ *
+ * @function uilayoutitem
+ * @category Property Decorators
+ *
+ * @example
+ * // Position properties in a grid layout
+ * @uimodel('user-form')
+ * class UserForm {
+ *   @attribute()
+ *   @uilayoutitem(1, 1) // First column, first row
+ *   firstName: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(2, 1) // Second column, first row
+ *   lastName: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(1, 2, { colspan: 2 }) // First column, second row, spans 2 columns
+ *   email: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(1, 3, { class: 'full-width' }) // First column, third row with custom class
+ *   bio: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uilayoutitem
+ *   participant RenderingEngine
+ *   participant LayoutContainer
+ *   Model->>uilayoutitem: Apply to property
+ *   uilayoutitem->>Model: Add layout item metadata
+ *   RenderingEngine->>Model: Get layout item metadata
+ *   Model->>RenderingEngine: Return column, row, and props
+ *   RenderingEngine->>LayoutContainer: Position element at grid coordinates
+ *   LayoutContainer->>RenderingEngine: Return positioned element
+ */
+export declare function uilayoutitem(col: number, row?: number, props?: Record<string, any>): (target: any, propertyKey: string) => void;

package/lib/ui/types.cjs

@@ -9,4 +9,4 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("./constants.cjs");
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/ui/types.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAGH,+CAAqC","sourcesContent":["/**\n * @description Type definitions for UI components and rendering\n * @summary Defines types and interfaces used throughout the UI decorators library\n * This module contains type definitions for field properties, UI metadata,\n * and other structures used in rendering UI components.\n * @module ui/types\n * @memberOf module:ui-decorators\n */\n\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { UIKeys } from \"./constants\";\n\n/**\n * @description Interface for defining a UI field or component\n * @summary Represents a renderable UI element with properties and children\n * This interface defines the structure of a UI field or component, including\n * its tag name, properties, and optional children elements.\n *\n * @interface FieldDefinition\n * @template T Additional properties type (defaults to void)\n * @memberOf module:ui-decorators\n *\n * @property {string} tag - The HTML element or component tag name\n * @property {string} [rendererId] - Optional ID of the renderer to use\n * @property props - Combined properties for the field\n * @property {FieldDefinition[]} [children] - Optional child elements\n * @property {UIListItemElementMetadata} [item] - Optional list item metadata\n */\nexport interface FieldDefinition<T = void> {\n  tag: string;\n  rendererId?: string;\n  props: T & FieldProperties;\n  children?: FieldDefinition<T>[];\n  item?: UIListItemElementMetadata;\n  col?: number | string[];\n  row?: number | string[];\n}\n\n/**\n * @description Interface for field properties including validation\n * @summary Defines common properties and validation rules for UI fields\n * This interface defines the standard properties that can be applied to\n * UI fields, including basic attributes and validation rules.\n *\n * @interface FieldProperties\n * @memberOf module:ui-decorators\n *\n * @property {string} name - The name of the field\n * @property {string} path - The full hierarchical path of the field\n * @property {string} childOf - The parent path of the immediate parent field, if nested\n * @property {string} type - The type of the field (e.g., 'text', 'number')\n * @property {string|number|Date} value - The current value of the field\n * @property {boolean} [hidden] - Whether the field is hidden\n * @property {boolean} [disabled] - Whether the field is disabled\n * @property {boolean} [required] - Whether the field is required\n * @property {boolean} [readonly] - Whether the field is read-only\n * @property {number} [maxLength] - Maximum length for text fields\n * @property {number} [minLength] - Minimum length for text fields\n * @property {number|Date} [max] - Maximum value for numeric or date fields\n * @property {number|Date} [min] - Minimum value for numeric or date fields\n * @property {string} [pattern] - Regex pattern for validation\n * @property {number} [step] - Step value for numeric fields\n * @property {string} [format] - Format string for date fields\n * @property {string} [equals] - Field must equal the value of this field\n * @property {string} [diff] - Field must differ from the value of this field\n * @property {string} [lessThan] - Field must be less than this field\n * @property {string} [lessThanOrEqual] - Field must be less than or equal to this field\n * @property {string} [greaterThan] - Field must be greater than this field\n * @property {string} [greaterThanOrEqual] - Field must be greater than or equal to this field\n */\nexport interface FieldProperties {\n  name: string;\n  path: string;\n  childOf?: string;\n  type: string;\n  value: string | number | Date;\n  hidden?: boolean;\n  disabled?: boolean;\n  // Validation\n  required?: boolean;\n  readonly?: boolean;\n  maxLength?: number;\n  minLength?: number;\n  max?: number | Date;\n  min?: number | Date;\n  pattern?: string;\n  step?: number;\n  format?: string;\n  [UIKeys.EQUALS]?: string;\n  [UIKeys.DIFF]?: string;\n  [UIKeys.LESS_THAN]?: string;\n  [UIKeys.LESS_THAN_OR_EQUAL]?: string;\n  [UIKeys.GREATER_THAN]?: string;\n  [UIKeys.GREATER_THAN_OR_EQUAL]?: string;\n}\n\n/**\n * @typedef UIElementMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIElementMetadata = {\n  tag: string;\n  props?: Record<string, any>;\n  serialize?: boolean;\n};\n\n/**\n * @typedef UIElementMetadata\n * @memberOf ui-decorators.ui.decorators\n */\nexport type UIModelMetadata = Omit<UIElementMetadata, \"serialize\">;\n\n/**\n * @typedef UIPropMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIPropMetadata = {\n  name: string;\n  stringify: boolean;\n};\n\n/**\n * @typedef CrudOperationKeys\n * @memberOf module:ui-decorators\n */\nexport type CrudOperationKeys =\n  | OperationKeys.CREATE\n  | OperationKeys.READ\n  | OperationKeys.UPDATE\n  | OperationKeys.DELETE;\n\n/**\n * @typedef UIListPropMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIListPropMetadata = {\n  name: string;\n  props: Record<string, any>;\n};\n\n/**\n * @typedef UIListItemModelMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIListItemModelMetadata = {\n  item: UIListItemElementMetadata;\n};\n\n/**\n * @typedef UIListItemElementMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIListItemElementMetadata = {\n  tag: string;\n  props?: Record<string, any>;\n  mapper?: Record<string, string>;\n};\n\n\n/**\n * @typedef UILayoutMetadata\n * @memberOf module:ui-decorators\n */\nexport type UILayoutMetadata = {\n  props: {\n    cols?: number | string[];\n    rows?: number;\n    props?: Record<string, any>;\n  }\n}\n\n/**\n * @typedef UIClassMetadata\n * @memberOf module:ui-decorators\n */\nexport type UIClassMetadata = UILayoutMetadata | UIModelMetadata | UIListItemModelMetadata;\n\n/**\n * @typedef UILayoutItemMetadata\n * @memberOf ui-decorators.ui.decorators\n */\nexport type UILayoutItemMetadata ={\n  name: string;\n  props: Record<string, any>;\n  col: number | string[];\n  row: number | string[];\n};\n\n/**\n * @typedef UIMediaBreakPoints\n * @memberOf module:ui-decorators\n */\nexport type UIMediaBreakPoints = 'xl' | 'l' | 'm' | 's' | 'medium' | 'large' | 'small' | 'xlarge';"]}

package/lib/ui/types.d.ts

@@ -30,6 +30,8 @@ export interface FieldDefinition<T = void> {
     props: T & FieldProperties;
     children?: FieldDefinition<T>[];
     item?: UIListItemElementMetadata;
+    col?: number | string[];
+    row?: number | string[];
 }
 /**
  * @description Interface for field properties including validation
@@ -109,6 +111,10 @@ export type UIPropMetadata = {
     name: string;
     stringify: boolean;
 };
+/**
+ * @typedef CrudOperationKeys
+ * @memberOf module:ui-decorators
+ */
 export type CrudOperationKeys = OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE;
 /**
  * @typedef UIListPropMetadata
@@ -126,7 +132,7 @@ export type UIListItemModelMetadata = {
     item: UIListItemElementMetadata;
 };
 /**
- * @typedef UIListItemElementMetada
+ * @typedef UIListItemElementMetadata
  * @memberOf module:ui-decorators
  */
 export type UIListItemElementMetadata = {
@@ -134,3 +140,34 @@ export type UIListItemElementMetadata = {
     props?: Record<string, any>;
     mapper?: Record<string, string>;
 };
+/**
+ * @typedef UILayoutMetadata
+ * @memberOf module:ui-decorators
+ */
+export type UILayoutMetadata = {
+    props: {
+        cols?: number | string[];
+        rows?: number;
+        props?: Record<string, any>;
+    };
+};
+/**
+ * @typedef UIClassMetadata
+ * @memberOf module:ui-decorators
+ */
+export type UIClassMetadata = UILayoutMetadata | UIModelMetadata | UIListItemModelMetadata;
+/**
+ * @typedef UILayoutItemMetadata
+ * @memberOf ui-decorators.ui.decorators
+ */
+export type UILayoutItemMetadata = {
+    name: string;
+    props: Record<string, any>;
+    col: number | string[];
+    row: number | string[];
+};
+/**
+ * @typedef UIMediaBreakPoints
+ * @memberOf module:ui-decorators
+ */
+export type UIMediaBreakPoints = 'xl' | 'l' | 'm' | 's' | 'medium' | 'large' | 'small' | 'xlarge';

package/lib/ui/utils.cjs

@@ -16,6 +16,8 @@ const db_decorators_1 = require("@decaf-ts/db-decorators");
  */
 function formatByType(type, value, ...args) {
     if (type === constants_1.UIKeys.DATE) {
+        if (!value)
+            return "";
         const format = args.shift() || constants_1.HTML5DateFormat;
         return (0, decorator_validation_1.formatDate)(new Date(value), format);
     }
@@ -29,14 +31,16 @@ function parseValueByType(type, value, fieldProps) {
             break;
         case constants_1.HTML5InputTypes.DATE: {
             const format = fieldProps.format;
-            result =
-                typeof value === decorator_validation_1.ReservedModels.NUMBER
-                    ? new Date(value)
-                    : value
-                        ? format
-                            ? (0, decorator_validation_1.parseDate)(format, value)
-                            : new Date(value)
-                        : undefined;
+            if (value) {
+                result =
+                    typeof value === decorator_validation_1.ReservedModels.NUMBER
+                        ? new Date(value)
+                        : value
+                            ? format
+                                ? (0, decorator_validation_1.parseDate)(format, value)
+                                : new Date(value)
+                            : undefined;
+            }
             break;
         }
         default:
@@ -92,4 +96,4 @@ function generateUIModelID(model) {
     const name = model.constructor.name;
     return `${name}-${id}`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdWkvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFlQSxvQ0FZQztBQUVELDRDQW9DQztBQUVELHNDQU9DO0FBRUQsZ0NBV0M7QUFFRCxnQ0FVQztBQUVELDhDQVVDO0FBL0dELHlFQUt3QztBQUN4QywrQ0FBdUU7QUFDdkUsMkRBQXFFO0FBR3JFOzs7O0dBSUc7QUFDSCxTQUFnQixZQUFZLENBQzFCLElBQVMsRUFDVCxLQUFVLEVBQ1YsR0FBRyxJQUFlO0lBRWxCLElBQUksSUFBSSxLQUFLLGtCQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDekIsSUFBRyxDQUFDLEtBQUs7WUFDTCxPQUFPLEVBQUUsQ0FBQztRQUNkLE1BQU0sTUFBTSxHQUFZLElBQUksQ0FBQyxLQUFLLEVBQWEsSUFBSSwyQkFBZSxDQUFDO1FBQ25FLE9BQU8sSUFBQSxpQ0FBVSxFQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRCxTQUFnQixnQkFBZ0IsQ0FDOUIsSUFBWSxFQUNaLEtBQXNCLEVBQ3RCLFVBQTJCO0lBRTNCLElBQUksTUFBTSxHQUF1QyxTQUFTLENBQUM7SUFDM0QsUUFBUSxJQUFJLEVBQUUsQ0FBQztRQUNiLEtBQUssMkJBQWUsQ0FBQyxNQUFNO1lBQ3pCLE1BQU0sR0FBRyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDOUIsTUFBTTtRQUNSLEtBQUssMkJBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQzFCLE1BQU0sTUFBTSxHQUF1QixVQUFVLENBQUMsTUFBTSxDQUFDO1lBQ3JELElBQUcsS0FBSyxFQUFFLENBQUM7Z0JBQ1QsTUFBTTtvQkFDSixPQUFPLEtBQUssS0FBSyxxQ0FBYyxDQUFDLE1BQU07d0JBQ3BDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUM7d0JBQ2pCLENBQUMsQ0FBQyxLQUFLOzRCQUNMLENBQUMsQ0FBQyxNQUFNO2dDQUNOLENBQUMsQ0FBQyxJQUFBLGdDQUFTLEVBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQztnQ0FDMUIsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQzs0QkFDbkIsQ0FBQyxDQUFDLFNBQVMsQ0FBQztZQUNwQixDQUFDO1lBQ0QsTUFBTTtRQUNSLENBQUM7UUFDRDtZQUNFLE1BQU07Z0JBQ0osT0FBTyxLQUFLLEtBQUsscUNBQWMsQ0FBQyxNQUFNO29CQUNwQyxDQUFDLENBQUMsVUFBVSxDQUFDLEtBQWUsQ0FBQztvQkFDN0IsQ0FBQyxDQUFDLE1BQU0sQ0FBQztJQUNqQixDQUFDO0lBQ0QsSUFBSSxPQUFPLE1BQU0sS0FBSyxXQUFXLEVBQUUsQ0FBQztRQUNsQyxNQUFNLElBQUksNkJBQWEsQ0FDckIsaUNBQWlDLElBQUksU0FBUyxPQUFPLEtBQUssTUFBTSxLQUFLLEVBQUUsQ0FDeEUsQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQsU0FBZ0IsYUFBYSxDQUFDLEtBQXNCO0lBQ2xELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQztRQUFFLE9BQU8sS0FBSyxDQUFDO0lBRTdELE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM3QixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQztRQUFFLE9BQU8sTUFBTSxDQUFDO0lBRWxDLE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFFRCxTQUFnQixVQUFVLENBQUMsS0FBYTtJQUN0QyxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU8sS0FBSyxDQUFDO0lBRXpCLE1BQU0sYUFBYSxHQUEyQjtRQUM1QyxHQUFHLEVBQUUsT0FBTztRQUNaLEdBQUcsRUFBRSxNQUFNO1FBQ1gsR0FBRyxFQUFFLE1BQU07S0FDWixDQUFDO0lBQ0YsT0FBTyxHQUFHLEtBQUssRUFBRSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRTtRQUMxQyxPQUFPLGFBQWEsQ0FBQyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUM7SUFDbkMsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsU0FBZ0IsVUFBVSxDQUFDLEtBQWE7SUFDdEMsTUFBTSxhQUFhLEdBQTJCO1FBQzVDLE9BQU8sRUFBRSxHQUFHO1FBQ1osTUFBTSxFQUFFLEdBQUc7UUFDWCxNQUFNLEVBQUUsR0FBRztLQUNaLENBQUM7SUFFRixPQUFPLEdBQUcsS0FBSyxFQUFFLENBQUMsT0FBTyxDQUFDLGtCQUFrQixFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7UUFDcEQsT0FBTyxhQUFhLENBQUMsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDO0lBQ25DLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVELFNBQWdCLGlCQUFpQixDQUFrQixLQUFRO0lBQ3pELElBQUksRUFBNEIsQ0FBQztJQUNqQyxJQUFJLENBQUM7UUFDSCxFQUFFLEdBQUcsSUFBQSwyQkFBVyxFQUFDLEtBQUssQ0FBb0IsQ0FBQztRQUMzQyw2REFBNkQ7SUFDL0QsQ0FBQztJQUFDLE9BQU8sQ0FBVSxFQUFFLENBQUM7UUFDcEIsRUFBRSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUNsQixDQUFDO0lBQ0QsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUM7SUFDcEMsT0FBTyxHQUFHLElBQUksSUFBSSxFQUFFLEVBQUUsQ0FBQztBQUN6QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgZm9ybWF0RGF0ZSxcbiAgTW9kZWwsXG4gIHBhcnNlRGF0ZSxcbiAgUmVzZXJ2ZWRNb2RlbHMsXG59IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IEhUTUw1RGF0ZUZvcm1hdCwgSFRNTDVJbnB1dFR5cGVzLCBVSUtleXMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IGZpbmRNb2RlbElkLCBJbnRlcm5hbEVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBGaWVsZFByb3BlcnRpZXMgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBmdW5jdGlvbiBmb3JtYXRCeVR5cGVcbiAqXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnVpLWRlY29yYXRvcnNcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdEJ5VHlwZShcbiAgdHlwZTogYW55LFxuICB2YWx1ZTogYW55LFxuICAuLi5hcmdzOiB1bmtub3duW11cbik6IHN0cmluZyB8IG51bWJlciB7XG4gIGlmICh0eXBlID09PSBVSUtleXMuREFURSkge1xuICAgIGlmKCF2YWx1ZSlcbiAgICAgICAgcmV0dXJuIFwiXCI7XG4gICAgY29uc3QgZm9ybWF0OiBzdHJpbmcgPSAoYXJncy5zaGlmdCgpIGFzIHN0cmluZykgfHwgSFRNTDVEYXRlRm9ybWF0O1xuICAgIHJldHVybiBmb3JtYXREYXRlKG5ldyBEYXRlKHZhbHVlKSwgZm9ybWF0KTtcbiAgfVxuICByZXR1cm4gdmFsdWU7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBwYXJzZVZhbHVlQnlUeXBlKFxuICB0eXBlOiBzdHJpbmcsXG4gIHZhbHVlOiBzdHJpbmcgfCBudW1iZXIsXG4gIGZpZWxkUHJvcHM6IEZpZWxkUHJvcGVydGllc1xuKTogc3RyaW5nIHwgbnVtYmVyIHwgRGF0ZSB7XG4gIGxldCByZXN1bHQ6IHN0cmluZyB8IG51bWJlciB8IERhdGUgfCB1bmRlZmluZWQgPSB1bmRlZmluZWQ7XG4gIHN3aXRjaCAodHlwZSkge1xuICAgIGNhc2UgSFRNTDVJbnB1dFR5cGVzLk5VTUJFUjpcbiAgICAgIHJlc3VsdCA9IHBhcnNlVG9OdW1iZXIodmFsdWUpO1xuICAgICAgYnJlYWs7XG4gICAgY2FzZSBIVE1MNUlucHV0VHlwZXMuREFURToge1xuICAgICAgY29uc3QgZm9ybWF0OiBzdHJpbmcgfCB1bmRlZmluZWQgPSBmaWVsZFByb3BzLmZvcm1hdDtcbiAgICAgIGlmKHZhbHVlKSB7XG4gICAgICAgIHJlc3VsdCA9XG4gICAgICAgICAgdHlwZW9mIHZhbHVlID09PSBSZXNlcnZlZE1vZGVscy5OVU1CRVJcbiAgICAgICAgICAgID8gbmV3IERhdGUodmFsdWUpXG4gICAgICAgICAgICA6IHZhbHVlXG4gICAgICAgICAgICAgID8gZm9ybWF0XG4gICAgICAgICAgICAgICAgPyBwYXJzZURhdGUoZm9ybWF0LCB2YWx1ZSlcbiAgICAgICAgICAgICAgICA6IG5ldyBEYXRlKHZhbHVlKVxuICAgICAgICAgICAgICA6IHVuZGVmaW5lZDtcbiAgICAgIH1cbiAgICAgIGJyZWFrO1xuICAgIH1cbiAgICBkZWZhdWx0OlxuICAgICAgcmVzdWx0ID1cbiAgICAgICAgdHlwZW9mIHZhbHVlID09PSBSZXNlcnZlZE1vZGVscy5TVFJJTkdcbiAgICAgICAgICA/IGVzY2FwZUh0bWwodmFsdWUgYXMgc3RyaW5nKVxuICAgICAgICAgIDogcmVzdWx0O1xuICB9XG4gIGlmICh0eXBlb2YgcmVzdWx0ID09PSBcInVuZGVmaW5lZFwiKSB7XG4gICAgdGhyb3cgbmV3IEludGVybmFsRXJyb3IoXG4gICAgICBgRmFpbGVkIHRvIHBhcnNlIHZhbHVlIG9mIHR5cGUgJHt0eXBlfSBmcm9tICR7dHlwZW9mIHZhbHVlfSAtICR7dmFsdWV9YFxuICAgICk7XG4gIH1cbiAgcmV0dXJuIHJlc3VsdDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHBhcnNlVG9OdW1iZXIodmFsdWU6IHN0cmluZyB8IG51bWJlcikge1xuICBpZiAodHlwZW9mIHZhbHVlID09PSBcIm51bWJlclwiICYmICFpc05hTih2YWx1ZSkpIHJldHVybiB2YWx1ZTtcblxuICBjb25zdCBwYXJzZWQgPSBOdW1iZXIodmFsdWUpO1xuICBpZiAoIWlzTmFOKHBhcnNlZCkpIHJldHVybiBwYXJzZWQ7XG5cbiAgcmV0dXJuIHVuZGVmaW5lZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVzY2FwZUh0bWwodmFsdWU6IHN0cmluZykge1xuICBpZiAoIXZhbHVlKSByZXR1cm4gdmFsdWU7XG5cbiAgY29uc3QgdGFnc1RvUmVwbGFjZTogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHtcbiAgICBcIiZcIjogXCImYW1wO1wiLFxuICAgIFwiPFwiOiBcIiZsdDtcIixcbiAgICBcIj5cIjogXCImZ3Q7XCIsXG4gIH07XG4gIHJldHVybiBgJHt2YWx1ZX1gLnJlcGxhY2UoL1smPD5dL2csICh0YWcpID0+IHtcbiAgICByZXR1cm4gdGFnc1RvUmVwbGFjZVt0YWddIHx8IHRhZztcbiAgfSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZXZlcnRIdG1sKHZhbHVlOiBzdHJpbmcpIHtcbiAgY29uc3QgdGFnc1RvUmVwbGFjZTogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHtcbiAgICBcIiZhbXA7XCI6IFwiJlwiLFxuICAgIFwiJmx0O1wiOiBcIjxcIixcbiAgICBcIiZndDtcIjogXCI+XCIsXG4gIH07XG5cbiAgcmV0dXJuIGAke3ZhbHVlfWAucmVwbGFjZSgvJmx0O3wmZ3Q7fCZhbXA7L2csICh0YWcpID0+IHtcbiAgICByZXR1cm4gdGFnc1RvUmVwbGFjZVt0YWddIHx8IHRhZztcbiAgfSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZVVJTW9kZWxJRDxNIGV4dGVuZHMgTW9kZWw+KG1vZGVsOiBNKSB7XG4gIGxldCBpZDogc3RyaW5nIHwgbnVtYmVyIHwgYmlnaW50O1xuICB0cnkge1xuICAgIGlkID0gZmluZE1vZGVsSWQobW9kZWwpIGFzIHN0cmluZyB8IG51bWJlcjtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG4gIH0gY2F0Y2ggKGU6IHVua25vd24pIHtcbiAgICBpZCA9IERhdGUubm93KCk7XG4gIH1cbiAgY29uc3QgbmFtZSA9IG1vZGVsLmNvbnN0cnVjdG9yLm5hbWU7XG4gIHJldHVybiBgJHtuYW1lfS0ke2lkfWA7XG59XG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/ui-decorators",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "description": "Extension of decorator validation to ui elements to allow for web integration",
   "type": "module",
   "exports": {