@decaf-ts/ui-decorators 0.5.15 → 0.5.16

package/lib/esm/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/esm/index.js

@@ -13,5 +13,5 @@ export * from "./ui/index.js";
  * @const VERSION
  * @memberOf module:ui-decorators
  */
-export const VERSION = "0.5.15";
+export const VERSION = "0.5.16";
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsaUNBQXdCO0FBQ3hCLDhCQUFxQjtBQUVyQjs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBVSSBkZWNvcmF0b3JzIG1vZHVsZSBmb3IgVHlwZVNjcmlwdCBhcHBsaWNhdGlvbnNcbiAqIEBzdW1tYXJ5IEEgY29sbGVjdGlvbiBvZiBkZWNvcmF0b3JzIGFuZCB1dGlsaXRpZXMgZm9yIGJ1aWxkaW5nIFVJIGNvbXBvbmVudHMgaW4gVHlwZVNjcmlwdCBhcHBsaWNhdGlvbnMuXG4gKiBUaGlzIG1vZHVsZSBleHBvcnRzIGZ1bmN0aW9uYWxpdHkgZnJvbSBib3RoIHRoZSBtb2RlbCBhbmQgVUkgc3VibW9kdWxlcywgcHJvdmlkaW5nIGRlY29yYXRvcnMgZm9yXG4gKiByZW5kZXJpbmcsIGNvbXBvbmVudCBkZWZpbml0aW9uLCBhbmQgVUkgc3RhdGUgbWFuYWdlbWVudC5cbiAqIEBtb2R1bGUgdWktZGVjb3JhdG9yc1xuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91aVwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHBhY2thZ2UgdmVyc2lvbiBzdHJpbmdcbiAqIEBzdW1tYXJ5IFN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb24gZm9yIHJlZmVyZW5jZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dWktZGVjb3JhdG9yc1xuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==

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

@@ -1,3 +1,4 @@
+import { UIMediaBreakPoints } from "../ui/types";
 /**
  * @description Decorator that tags a class as a UI model
  * @summary Adds rendering capabilities to a model class by providing a render method
@@ -121,4 +122,116 @@ export declare function renderedBy(engine: string): (target: object, propertyKey
  *   RenderingEngine->>System: renders with list item styling
  */
 export declare function uilistitem(tag?: string, props?: Record<string, any>): (original: any, propertyKey?: any) => void;
+/**
+ * @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
+ */
 export declare function uihandlers(props?: Record<string, any>): (original: any) => void;
+/**
+ * @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
+ */
+export declare function uilayout(tag: string, cols?: number, rows?: number | string[], breakpoint?: UIMediaBreakPoints): (original: any, propertyKey?: any) => void;

package/lib/esm/model/decorators.js

@@ -146,6 +146,59 @@ export function uilistitem(tag, props) {
         return metadata(RenderingEngine.key(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
+ */
 export function uihandlers(props) {
     return (original) => {
         const meta = {
@@ -154,4 +207,67 @@ export function uihandlers(props) {
         return metadata(RenderingEngine.key(UIKeys.HANDLERS), meta)(original);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/model/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,6BAAwB;AACzC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,6BAAwB;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,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,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,OAAO,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,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,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;AACJ,CAAC;AAGD,MAAM,UAAU,UAAU,CAAC,KAA2B;IACpD,OAAO,CAAC,QAAa,EAAE,EAAE;QACvB,MAAM,IAAI,GAAG;YACX,QAAQ,EAAE,KAAK;SAChB,CAAC;QACF,OAAO,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,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
+ */
+export 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":"AAAA,OAAO,EAAE,MAAM,EAAE,6BAAwB;AACzC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,6BAAwB;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,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,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,OAAO,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,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,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,UAAU,UAAU,CAAC,KAA2B;IACpD,OAAO,CAAC,QAAa,EAAE,EAAE;QACvB,MAAM,IAAI,GAAG;YACX,QAAQ,EAAE,KAAK;SAChB,CAAC;QACF,OAAO,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,UAAU,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}"]}

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

@@ -51,6 +51,19 @@ export declare abstract class RenderingEngine<T = void, R = FieldDefinition<T>>
      * @returns {string} The translated type.
      */
     translate(key: string, toView?: boolean): string;
+    /**
+     * @description Retrieves class decorator metadata for a model instance
+     * @summary Extracts UI-related class decorators from a model and returns them as an array
+     * This method collects metadata from various UI class decorators including @uimodel,
+     * @uilistitem, @uihandlers, and @uilayout applied to the model class.
+     *
+     * @template M Type extending Model
+     * @param {M} model - The model instance to extract metadata from
+     * @returns {UIClassMetadata[]} Array of UI class metadata objects
+     *
+     * @private
+     */
+    private getClassDecoratorsMetadata;
     /**
      * @description Checks if a type is validatable by its nature.
      * @summary Determines if a given UI key represents a type that is inherently validatable.
@@ -109,6 +122,21 @@ export declare abstract class RenderingEngine<T = void, R = FieldDefinition<T>>
      *  RE-->>C: FieldDefinition<T>
      */
     protected toFieldDefinition<M extends Model>(model: M, globalProps?: Record<string, unknown>, generateId?: boolean): FieldDefinition<T>;
+    /**
+     * @description Processes layout items for grid positioning
+     * @summary Maps child field definitions to their corresponding layout positions
+     * This method iterates through child field definitions and applies layout metadata
+     * from @uilayoutitem decorators to position them correctly in a grid layout.
+     *
+     * @param {FieldDefinition[]} children - Array of child field definitions to process
+     * @param {Record<string, any>} uiDecorators - UI decorator metadata keyed by property name
+     * @returns {FieldDefinition[]} Array of field definitions with layout positioning applied
+     *
+     * @example
+     * // Internal usage - positions children in grid layout
+     * const layoutChildren = this.getLayoutItems(childDefinitions, decoratorMetadata);
+     */
+    getLayoutItems(children: FieldDefinition<any>[], uiDecorators: Record<string, any>): FieldDefinition<any>[];
     /**
      * @description Renders a model with global properties and additional arguments.
      * @summary Abstract method to be implemented by subclasses to define specific rendering behavior.