@decaf-ts/ui-decorators 0.5.15 → 0.5.16

package/lib/esm/ui/decorators.js

@@ -308,4 +308,64 @@ export function uilistprop(propName = undefined, props) {
         propMetadata(RenderingEngine.key(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
+ */
+export function uilayoutitem(col, row = 1, props = {}) {
+    return (target, propertyKey) => {
+        const metadata = {
+            name: propertyKey,
+            col,
+            row,
+            props: Object.assign({}, props),
+        };
+        propMetadata(RenderingEngine.key(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/esm/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/esm/ui/types.js

@@ -7,4 +7,4 @@
  * @memberOf module:ui-decorators
  */
 import { UIKeys } from "./constants.js";
-//# 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,OAAO,EAAE,MAAM,EAAE,uBAAoB","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/esm/ui/utils.js

@@ -8,6 +8,8 @@ import { findModelId, InternalError } from "@decaf-ts/db-decorators";
  */
 export function formatByType(type, value, ...args) {
     if (type === UIKeys.DATE) {
+        if (!value)
+            return "";
         const format = args.shift() || HTML5DateFormat;
         return formatDate(new Date(value), format);
     }
@@ -21,14 +23,16 @@ export function parseValueByType(type, value, fieldProps) {
             break;
         case HTML5InputTypes.DATE: {
             const format = fieldProps.format;
-            result =
-                typeof value === ReservedModels.NUMBER
-                    ? new Date(value)
-                    : value
-                        ? format
-                            ? parseDate(format, value)
-                            : new Date(value)
-                        : undefined;
+            if (value) {
+                result =
+                    typeof value === ReservedModels.NUMBER
+                        ? new Date(value)
+                        : value
+                            ? format
+                                ? parseDate(format, value)
+                                : new Date(value)
+                            : undefined;
+            }
             break;
         }
         default:
@@ -84,4 +88,4 @@ export 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,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

package/lib/index.cjs

@@ -30,5 +30,5 @@ __exportStar(require("./ui/index.cjs"), exports);
  * @const VERSION
  * @memberOf module:ui-decorators
  */
-exports.VERSION = "0.5.15";
+exports.VERSION = "0.5.16";
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxvREFBd0I7QUFDeEIsaURBQXFCO0FBRXJCOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gVUkgZGVjb3JhdG9ycyBtb2R1bGUgZm9yIFR5cGVTY3JpcHQgYXBwbGljYXRpb25zXG4gKiBAc3VtbWFyeSBBIGNvbGxlY3Rpb24gb2YgZGVjb3JhdG9ycyBhbmQgdXRpbGl0aWVzIGZvciBidWlsZGluZyBVSSBjb21wb25lbnRzIGluIFR5cGVTY3JpcHQgYXBwbGljYXRpb25zLlxuICogVGhpcyBtb2R1bGUgZXhwb3J0cyBmdW5jdGlvbmFsaXR5IGZyb20gYm90aCB0aGUgbW9kZWwgYW5kIFVJIHN1Ym1vZHVsZXMsIHByb3ZpZGluZyBkZWNvcmF0b3JzIGZvclxuICogcmVuZGVyaW5nLCBjb21wb25lbnQgZGVmaW5pdGlvbiwgYW5kIFVJIHN0YXRlIG1hbmFnZW1lbnQuXG4gKiBAbW9kdWxlIHVpLWRlY29yYXRvcnNcbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdWlcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCBwYWNrYWdlIHZlcnNpb24gc3RyaW5nXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uIGZvciByZWZlcmVuY2VcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnVpLWRlY29yYXRvcnNcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=

package/lib/index.d.ts

@@ -13,4 +13,4 @@ export * from "./ui";
  * @const VERSION
  * @memberOf module:ui-decorators
  */
-export declare const VERSION = "0.5.15";
+export declare const VERSION = "0.5.16";

package/lib/model/decorators.cjs

@@ -4,6 +4,7 @@ exports.uimodel = uimodel;
 exports.renderedBy = renderedBy;
 exports.uilistitem = uilistitem;
 exports.uihandlers = uihandlers;
+exports.uilayout = uilayout;
 const constants_1 = require("./../ui/constants.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
 const Rendering_1 = require("./../ui/Rendering.cjs");
@@ -152,6 +153,59 @@ function uilistitem(tag, props) {
         return (0, reflection_1.metadata)(Rendering_1.RenderingEngine.key(constants_1.UIKeys.UILISTITEM), meta)(original);
     };
 }
+/**
+ * @description Decorator that adds event handlers to a UI model
+ * @summary Specifies event handlers that should be attached to the rendered model
+ * This decorator allows you to define event handlers that will be automatically
+ * attached to the rendered UI element. The handlers are passed as properties
+ * to the rendering engine.
+ *
+ * @param {Record<string, any>} [props] Object containing event handler functions and other properties
+ * @return {Function} A class decorator function
+ *
+ * @function uihandlers
+ * @category Class Decorators
+ *
+ * @example
+ * // Add event handlers to a model
+ * @uimodel('button')
+ * @uihandlers({
+ *   onClick: (event) => console.log('Button clicked'),
+ *   onMouseOver: (event) => console.log('Mouse over button'),
+ *   disabled: false
+ * })
+ * class ClickableButton extends Model {
+ *   @attribute()
+ *   label: string;
+ * }
+ *
+ * // Add form submission handlers
+ * @uimodel('form')
+ * @uihandlers({
+ *   onSubmit: (event) => {
+ *     event.preventDefault();
+ *     console.log('Form submitted');
+ *   },
+ *   onReset: (event) => console.log('Form reset')
+ * })
+ * class ContactForm extends Model {
+ *   @attribute()
+ *   email: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant System
+ *   participant uihandlers
+ *   participant Model
+ *   participant RenderingEngine
+ *   participant UI
+ *   System->>uihandlers: apply to Model
+ *   uihandlers->>Model: adds handler metadata
+ *   Model->>RenderingEngine: requests rendering with handlers
+ *   RenderingEngine->>UI: renders element with event handlers attached
+ *   UI->>Model: triggers handlers on events
+ */
 function uihandlers(props) {
     return (original) => {
         const meta = {
@@ -160,4 +214,67 @@ function uihandlers(props) {
         return (0, reflection_1.metadata)(Rendering_1.RenderingEngine.key(constants_1.UIKeys.HANDLERS), meta)(original);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/model/decorators.ts"],"names":[],"mappings":";;AAgDA,0BASC;AAkCD,gCAEC;AA+CD,gCAWC;AAGD,gCAOC;AAjKD,qDAAyC;AACzC,qDAAuD;AACvD,qDAAkD;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,SAAgB,OAAO,CAAC,GAAY,EAAE,KAA2B;IAC/D,6DAA6D;IAC7D,OAAO,CAAC,QAAa,EAAE,WAAiB,EAAE,EAAE;QAC1C,MAAM,IAAI,GAAoB;YAC5B,GAAG,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI;YACzB,KAAK,EAAE,KAAK;SACb,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,SAAgB,UAAU,CAAC,MAAc;IACvC,OAAO,IAAA,kBAAK,EAAC,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,SAAgB,UAAU,CAAC,GAAY,EAAE,KAA2B;IAClE,6DAA6D;IAC7D,OAAO,CAAC,QAAa,EAAE,WAAiB,EAAE,EAAE;QAC1C,MAAM,IAAI,GAA4B;YACpC,IAAI,EAAE;gBACJ,GAAG,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI;gBACzB,KAAK,EAAE,KAAK;aACb;SACF,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;AACJ,CAAC;AAGD,SAAgB,UAAU,CAAC,KAA2B;IACpD,OAAO,CAAC,QAAa,EAAE,EAAE;QACvB,MAAM,IAAI,GAAG;YACX,QAAQ,EAAE,KAAK;SAChB,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { UIKeys } from \"../ui/constants\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { RenderingEngine } from \"../ui/Rendering\";\nimport { UIListItemModelMetadata, UIModelMetadata } from \"../ui/types\";\n\n/**\n * @description Decorator that tags a class as a UI model\n * @summary Adds rendering capabilities to a model class by providing a render method\n * This decorator applies metadata to the class that enables it to be rendered by the UI rendering engine.\n * The model will be rendered with the specified tag and properties.\n *\n * @param {string} [tag] The HTML tag to use when rendering this model (defaults to class name)\n * @param {Record<string, any>} [props] Additional properties to pass to the rendered element\n * @return {Function} A class decorator function\n *\n * @function uimodel\n * @category Class Decorators\n *\n * @example\n * // Basic usage with default tag (class name)\n * @uimodel()\n * class UserProfile extends Model {\n *   @attribute()\n *   name: string;\n *\n *   @attribute()\n *   email: string;\n * }\n *\n * // Usage with custom tag and properties\n * @uimodel('div', { class: 'user-card' })\n * class UserCard extends Model {\n *   @attribute()\n *   username: string;\n * }\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 */\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\n/**\n * @description Decorator that specifies which rendering engine to use for a model\n * @summary Associates a model with a specific rendering engine implementation\n * This decorator allows you to override the default rendering engine for a specific model class,\n * enabling different rendering strategies for different models.\n *\n * @param {string} engine The name of the rendering engine to use\n * @return {Function} A class decorator function\n *\n * @function renderedBy\n * @category Class Decorators\n *\n * @example\n * // Specify a custom rendering engine for a model\n * @uimodel()\n * @renderedBy('react')\n * class ReactComponent extends Model {\n *   @attribute()\n *   title: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant renderedBy\n *   participant Model\n *   participant RenderingEngine\n *   System->>renderedBy: apply to Model\n *   renderedBy->>Model: adds engine metadata\n *   Model->>RenderingEngine: uses specified engine\n *   RenderingEngine->>System: renders with custom engine\n */\nexport function renderedBy(engine: string) {\n  return apply(metadata(RenderingEngine.key(UIKeys.RENDERED_BY), engine));\n}\n\n/**\n * @description Decorator that tags a model as a list item for UI rendering\n * @summary Specifies how a model should be rendered when displayed in a list context\n * This decorator applies metadata to the class that enables it to be rendered as a list item\n * by the UI rendering engine. The model will be rendered with the specified tag and properties\n * when it appears in a list.\n *\n * @param {string} [tag] The HTML tag to use when rendering this model as a list item (defaults to class name)\n * @param {Record<string, any>} [props] Additional properties to pass to the rendered list item element\n * @return {Function} A class decorator function\n *\n * @function uilistitem\n * @category Class Decorators\n *\n * @example\n * // Basic usage with default tag (class name)\n * @uimodel()\n * @uilistitem()\n * class TodoItem extends Model {\n *   @attribute()\n *   title: string;\n *\n *   @attribute()\n *   completed: boolean;\n * }\n *\n * // Usage with custom tag and properties\n * @uimodel()\n * @uilistitem('li', { class: 'list-group-item' })\n * class ListItem extends Model {\n *   @attribute()\n *   text: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uilistitem\n *   participant Model\n *   participant RenderingEngine\n *   System->>uilistitem: apply to Model\n *   uilistitem->>Model: adds list item metadata\n *   Model->>RenderingEngine: uses list item metadata when in list context\n *   RenderingEngine->>System: renders with list item styling\n */\nexport function uilistitem(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: UIListItemModelMetadata = {\n      item: {\n        tag: tag || original.name,\n        props: props,\n      },\n    };\n    return metadata(RenderingEngine.key(UIKeys.UILISTITEM), meta)(original);\n  };\n}\n\n\nexport function uihandlers(props?: Record<string, any>) {\n  return (original: any) => {\n    const meta = {\n      handlers: props\n    };\n    return metadata(RenderingEngine.key(UIKeys.HANDLERS), meta)(original);\n  };\n}"]}
+/**
+ * @description Decorator that creates a layout container with grid specifications
+ * @summary Combines UI model functionality with layout grid configuration
+ * This decorator creates a UI model that acts as a layout container with specified
+ * column and row configurations. It's a convenience decorator that combines
+ * @uimodel with layout-specific properties for responsive grid layouts.
+ *
+ * @param {string} tag The HTML tag to use for the layout container
+ * @param {number} [cols=1] Number of columns in the grid layout
+ * @param {number|string[]} [rows=1] Number of rows or array of row definitions
+ * @param {UIMediaBreakPoints} [breakpoint='m'] Media breakpoint for responsive behavior
+ * @return {Function} A class decorator function
+ *
+ * @function uilayout
+ * @category Class Decorators
+ *
+ * @example
+ * // Create a simple 2-column layout
+ * @uilayout('div', 2, 3)
+ * class TwoColumnLayout extends Model {
+ *   @attribute()
+ *   @uilayoutitem(1, 1)
+ *   header: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(1, 2)
+ *   leftContent: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(2, 2)
+ *   rightContent: string;
+ * }
+ *
+ * // Create a responsive layout with custom breakpoint
+ * @uilayout('section', 3, 2, 'l')
+ * class ResponsiveLayout extends Model {
+ *   @attribute()
+ *   @uilayoutitem(1, 1)
+ *   title: string;
+ *
+ *   @attribute()
+ *   @uilayoutitem(2, 1)
+ *   subtitle: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant System
+ *   participant uilayout
+ *   participant uimodel
+ *   participant Model
+ *   participant RenderingEngine
+ *   System->>uilayout: apply to Model
+ *   uilayout->>uimodel: call with layout props
+ *   uimodel->>Model: adds model metadata with layout config
+ *   Model->>RenderingEngine: requests rendering as layout container
+ *   RenderingEngine->>System: renders grid layout with specified dimensions
+ */
+function uilayout(tag, cols = 1, rows = 1, breakpoint = 'm') {
+    return (original, propertyKey) => {
+        return uimodel(tag, { cols, rows, breakpoint })(original, propertyKey);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/model/decorators.ts"],"names":[],"mappings":";;AAgDA,0BASC;AAkCD,gCAEC;AA+CD,gCAWC;AAuDD,gCAOC;AA4DD,4BAIC;AArRD,qDAAyC;AACzC,qDAAuD;AACvD,qDAAkD;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,SAAgB,OAAO,CAAC,GAAY,EAAE,KAA2B;IAC/D,6DAA6D;IAC7D,OAAO,CAAC,QAAa,EAAE,WAAiB,EAAE,EAAE;QAC1C,MAAM,IAAI,GAAoB;YAC5B,GAAG,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI;YACzB,KAAK,EAAE,KAAK;SACb,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,SAAgB,UAAU,CAAC,MAAc;IACvC,OAAO,IAAA,kBAAK,EAAC,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,SAAgB,UAAU,CAAC,GAAY,EAAE,KAA2B;IAClE,6DAA6D;IAC7D,OAAO,CAAC,QAAa,EAAE,WAAiB,EAAE,EAAE;QAC1C,MAAM,IAAI,GAA4B;YACpC,IAAI,EAAE;gBACJ,GAAG,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI;gBACzB,KAAK,EAAE,KAAK;aACb;SACF,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,SAAgB,UAAU,CAAC,KAA2B;IACpD,OAAO,CAAC,QAAa,EAAE,EAAE;QACvB,MAAM,IAAI,GAAG;YACX,QAAQ,EAAE,KAAK;SAChB,CAAC;QACF,OAAO,IAAA,qBAAQ,EAAC,2BAAe,CAAC,GAAG,CAAC,kBAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,SAAgB,QAAQ,CAAC,GAAW,EAAE,OAAe,CAAC,EAAE,OAA0B,CAAC,EAAE,aAAiC,GAAG;IACvH,OAAO,CAAC,QAAa,EAAE,WAAiB,EAAE,EAAE;QAC1C,OAAO,OAAO,CAAC,GAAG,EAAE,EAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { UIKeys } from \"../ui/constants\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { RenderingEngine } from \"../ui/Rendering\";\nimport { UIListItemModelMetadata, UIMediaBreakPoints, UIModelMetadata } from \"../ui/types\";\n\n/**\n * @description Decorator that tags a class as a UI model\n * @summary Adds rendering capabilities to a model class by providing a render method\n * This decorator applies metadata to the class that enables it to be rendered by the UI rendering engine.\n * The model will be rendered with the specified tag and properties.\n *\n * @param {string} [tag] The HTML tag to use when rendering this model (defaults to class name)\n * @param {Record<string, any>} [props] Additional properties to pass to the rendered element\n * @return {Function} A class decorator function\n *\n * @function uimodel\n * @category Class Decorators\n *\n * @example\n * // Basic usage with default tag (class name)\n * @uimodel()\n * class UserProfile extends Model {\n *   @attribute()\n *   name: string;\n *\n *   @attribute()\n *   email: string;\n * }\n *\n * // Usage with custom tag and properties\n * @uimodel('div', { class: 'user-card' })\n * class UserCard extends Model {\n *   @attribute()\n *   username: string;\n * }\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 */\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\n/**\n * @description Decorator that specifies which rendering engine to use for a model\n * @summary Associates a model with a specific rendering engine implementation\n * This decorator allows you to override the default rendering engine for a specific model class,\n * enabling different rendering strategies for different models.\n *\n * @param {string} engine The name of the rendering engine to use\n * @return {Function} A class decorator function\n *\n * @function renderedBy\n * @category Class Decorators\n *\n * @example\n * // Specify a custom rendering engine for a model\n * @uimodel()\n * @renderedBy('react')\n * class ReactComponent extends Model {\n *   @attribute()\n *   title: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant renderedBy\n *   participant Model\n *   participant RenderingEngine\n *   System->>renderedBy: apply to Model\n *   renderedBy->>Model: adds engine metadata\n *   Model->>RenderingEngine: uses specified engine\n *   RenderingEngine->>System: renders with custom engine\n */\nexport function renderedBy(engine: string) {\n  return apply(metadata(RenderingEngine.key(UIKeys.RENDERED_BY), engine));\n}\n\n/**\n * @description Decorator that tags a model as a list item for UI rendering\n * @summary Specifies how a model should be rendered when displayed in a list context\n * This decorator applies metadata to the class that enables it to be rendered as a list item\n * by the UI rendering engine. The model will be rendered with the specified tag and properties\n * when it appears in a list.\n *\n * @param {string} [tag] The HTML tag to use when rendering this model as a list item (defaults to class name)\n * @param {Record<string, any>} [props] Additional properties to pass to the rendered list item element\n * @return {Function} A class decorator function\n *\n * @function uilistitem\n * @category Class Decorators\n *\n * @example\n * // Basic usage with default tag (class name)\n * @uimodel()\n * @uilistitem()\n * class TodoItem extends Model {\n *   @attribute()\n *   title: string;\n *\n *   @attribute()\n *   completed: boolean;\n * }\n *\n * // Usage with custom tag and properties\n * @uimodel()\n * @uilistitem('li', { class: 'list-group-item' })\n * class ListItem extends Model {\n *   @attribute()\n *   text: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uilistitem\n *   participant Model\n *   participant RenderingEngine\n *   System->>uilistitem: apply to Model\n *   uilistitem->>Model: adds list item metadata\n *   Model->>RenderingEngine: uses list item metadata when in list context\n *   RenderingEngine->>System: renders with list item styling\n */\nexport function uilistitem(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: UIListItemModelMetadata = {\n      item: {\n        tag: tag || original.name,\n        props: props,\n      },\n    };\n    return metadata(RenderingEngine.key(UIKeys.UILISTITEM), meta)(original);\n  };\n}\n\n/**\n * @description Decorator that adds event handlers to a UI model\n * @summary Specifies event handlers that should be attached to the rendered model\n * This decorator allows you to define event handlers that will be automatically\n * attached to the rendered UI element. The handlers are passed as properties\n * to the rendering engine.\n *\n * @param {Record<string, any>} [props] Object containing event handler functions and other properties\n * @return {Function} A class decorator function\n *\n * @function uihandlers\n * @category Class Decorators\n *\n * @example\n * // Add event handlers to a model\n * @uimodel('button')\n * @uihandlers({\n *   onClick: (event) => console.log('Button clicked'),\n *   onMouseOver: (event) => console.log('Mouse over button'),\n *   disabled: false\n * })\n * class ClickableButton extends Model {\n *   @attribute()\n *   label: string;\n * }\n *\n * // Add form submission handlers\n * @uimodel('form')\n * @uihandlers({\n *   onSubmit: (event) => {\n *     event.preventDefault();\n *     console.log('Form submitted');\n *   },\n *   onReset: (event) => console.log('Form reset')\n * })\n * class ContactForm extends Model {\n *   @attribute()\n *   email: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uihandlers\n *   participant Model\n *   participant RenderingEngine\n *   participant UI\n *   System->>uihandlers: apply to Model\n *   uihandlers->>Model: adds handler metadata\n *   Model->>RenderingEngine: requests rendering with handlers\n *   RenderingEngine->>UI: renders element with event handlers attached\n *   UI->>Model: triggers handlers on events\n */\nexport function uihandlers(props?: Record<string, any>) {\n  return (original: any) => {\n    const meta = {\n      handlers: props\n    };\n    return metadata(RenderingEngine.key(UIKeys.HANDLERS), meta)(original);\n  };\n}\n\n/**\n * @description Decorator that creates a layout container with grid specifications\n * @summary Combines UI model functionality with layout grid configuration\n * This decorator creates a UI model that acts as a layout container with specified\n * column and row configurations. It's a convenience decorator that combines\n * @uimodel with layout-specific properties for responsive grid layouts.\n *\n * @param {string} tag The HTML tag to use for the layout container\n * @param {number} [cols=1] Number of columns in the grid layout\n * @param {number|string[]} [rows=1] Number of rows or array of row definitions\n * @param {UIMediaBreakPoints} [breakpoint='m'] Media breakpoint for responsive behavior\n * @return {Function} A class decorator function\n *\n * @function uilayout\n * @category Class Decorators\n *\n * @example\n * // Create a simple 2-column layout\n * @uilayout('div', 2, 3)\n * class TwoColumnLayout extends Model {\n *   @attribute()\n *   @uilayoutitem(1, 1)\n *   header: string;\n *\n *   @attribute()\n *   @uilayoutitem(1, 2)\n *   leftContent: string;\n *\n *   @attribute()\n *   @uilayoutitem(2, 2)\n *   rightContent: string;\n * }\n *\n * // Create a responsive layout with custom breakpoint\n * @uilayout('section', 3, 2, 'l')\n * class ResponsiveLayout extends Model {\n *   @attribute()\n *   @uilayoutitem(1, 1)\n *   title: string;\n *\n *   @attribute()\n *   @uilayoutitem(2, 1)\n *   subtitle: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uilayout\n *   participant uimodel\n *   participant Model\n *   participant RenderingEngine\n *   System->>uilayout: apply to Model\n *   uilayout->>uimodel: call with layout props\n *   uimodel->>Model: adds model metadata with layout config\n *   Model->>RenderingEngine: requests rendering as layout container\n *   RenderingEngine->>System: renders grid layout with specified dimensions\n */\nexport function uilayout(tag: string, cols: number = 1, rows: number | string[] = 1, breakpoint: UIMediaBreakPoints = 'm') {\n  return (original: any, propertyKey?: any) => {\n    return uimodel(tag, {cols, rows, breakpoint})(original, propertyKey);\n  };\n}"]}