@decaf-ts/ui-decorators 0.5.9 → 0.5.11

package/lib/esm/ui/decorators.js

@@ -4,50 +4,177 @@ import { propMetadata } from "@decaf-ts/decorator-validation";
 import { RenderingEngine } from "./Rendering";
 import { OperationKeys } from "@decaf-ts/db-decorators";
 /**
- * @namespace ui-decorators.ui.decorators
- * @memberOf ui-decorators.ui
+ * @description Decorator that hides a property during specific CRUD operations
+ * @summary Controls property visibility based on operation type
+ * This decorator allows you to specify which CRUD operations should hide a property
+ * in the UI. The property will only be visible during operations not specified.
+ *
+ * @param operations - The CRUD operations during which the property should be hidden
+ * @return {Function} A property decorator function
+ *
+ * @function hideOn
+ * @category Property Decorators
+ *
+ * @example
+ * // Hide the password field during READ operations
+ * class User {
+ *   @attribute()
+ *   username: string;
+ *
+ *   @attribute()
+ *   @hideOn(OperationKeys.READ)
+ *   password: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant hideOn
+ *   participant RenderingEngine
+ *   participant UI
+ *   Model->>hideOn: Apply to property
+ *   hideOn->>Model: Add hidden metadata
+ *   RenderingEngine->>Model: Check if property should be hidden
+ *   Model->>RenderingEngine: Return hidden operations
+ *   RenderingEngine->>UI: Render or hide based on current operation
  */
 export function hideOn(...operations) {
     return propMetadata(RenderingEngine.key(UIKeys.HIDDEN), operations);
 }
+/**
+ * @description Decorator that completely hides a property in all UI operations
+ * @summary Makes a property invisible in all CRUD operations
+ * This decorator is a convenience wrapper around hideOn that hides a property
+ * during all CRUD operations (CREATE, READ, UPDATE, DELETE).
+ *
+ * @return {Function} A property decorator function
+ *
+ * @function hidden
+ * @category Property Decorators
+ *
+ * @example
+ * // Completely hide the internalId field in the UI
+ * class Product {
+ *   @attribute()
+ *   name: string;
+ *
+ *   @attribute()
+ *   @hidden()
+ *   internalId: string;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant hidden
+ *   participant hideOn
+ *   participant RenderingEngine
+ *   Model->>hidden: Apply to property
+ *   hidden->>hideOn: Call with all operations
+ *   hideOn->>Model: Add hidden metadata
+ *   RenderingEngine->>Model: Check if property should be hidden
+ *   Model->>RenderingEngine: Return all operations
+ *   RenderingEngine->>UI: Always hide property
+ */
 export function hidden() {
     return hideOn(OperationKeys.CREATE, OperationKeys.READ, OperationKeys.UPDATE, OperationKeys.DELETE);
 }
 /**
- * Adds the UIElement definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ * @description Decorator that specifies how a property should be rendered as a UI element
+ * @summary Maps a model property to a specific UI element with custom properties
+ * This decorator allows you to define which HTML element or component should be used
+ * to render a specific property, along with any additional properties to pass to that element.
+ *
+ * @param {string} tag The HTML element or component tag name to use for rendering
+ * @param {Record<string, any>} [props] Additional properties to pass to the element
+ * @param {boolean} [serialize=false] Whether the property should be serialized
+ * @return {Function} A property decorator function
+ *
+ * @function uielement
+ * @category Property Decorators
  *
- * @param {string} tag The component/HTML element tag name
- * @param {{}} [props] The properties to pass to that component/HTML Element
- * @param serialize
+ * @example
+ * // Render a property as a text input
+ * class LoginForm {
+ *   @attribute()
+ *   @uielement('input', { type: 'text', placeholder: 'Enter username' })
+ *   username: string;
  *
- * @decorator uielement
+ *   @attribute()
+ *   @uielement('input', { type: 'password', placeholder: 'Enter password' })
+ *   password: string;
  *
- * @category Decorators
- * @subcategory ui-decorators
+ *   @attribute()
+ *   @uielement('button', { class: 'btn-primary' })
+ *   submit: string = 'Login';
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uielement
+ *   participant RenderingEngine
+ *   participant UI
+ *   Model->>uielement: Apply to property
+ *   uielement->>Model: Add element metadata
+ *   RenderingEngine->>Model: Get element metadata
+ *   Model->>RenderingEngine: Return tag and props
+ *   RenderingEngine->>UI: Render with specified element
  */
 export function uielement(tag, props, serialize = false) {
     return (original, propertyKey) => {
         const metadata = {
             tag: tag,
             serialize: serialize,
-            props: Object.assign({
+            props: Object.assign({}, props || {}, {
                 name: propertyKey,
-            }, props || {}),
+            }),
         };
         return propMetadata(RenderingEngine.key(UIKeys.ELEMENT), metadata)(original, propertyKey);
     };
 }
 /**
- * Adds the UIProp definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ * @description Decorator that maps a model property to a UI component property
+ * @summary Specifies how a property should be passed to a UI component
+ * This decorator allows you to define how a model property should be mapped to
+ * a property of the UI component when rendering. It requires the class to be
+ * decorated with @uimodel.
+ *
+ * @param {string} [propName] The name of the property to pass to the component (defaults to the property key)
+ * @param {boolean} [stringify=false] Whether to stringify the property value
+ * @return {Function} A property decorator function
  *
- * this requires a '@uimodel' with a defined tag
+ * @function uiprop
+ * @category Property Decorators
  *
- * @param {string} [propName] the property name that will be passed to the component. defaults to the PropertyKey
+ * @example
+ * // Map model properties to component properties
+ * @uimodel('user-profile')
+ * class UserProfile {
+ *   @attribute()
+ *   @uiprop() // Will be passed as 'fullName' to the component
+ *   fullName: string;
  *
- * @decorator uiprop
+ *   @attribute()
+ *   @uiprop('userEmail') // Will be passed as 'userEmail' to the component
+ *   email: string;
  *
- * @category Decorators
- * @subcategory ui-decorators
+ *   @attribute()
+ *   @uiprop('userData', true) // Will be passed as stringified JSON
+ *   userData: Record<string, any>;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uiprop
+ *   participant RenderingEngine
+ *   participant Component
+ *   Model->>uiprop: Apply to property
+ *   uiprop->>Model: Add prop metadata
+ *   RenderingEngine->>Model: Get prop metadata
+ *   Model->>RenderingEngine: Return prop name and stringify flag
+ *   RenderingEngine->>Component: Pass property with specified name
  */
 export function uiprop(propName = undefined, stringify = false) {
     return (target, propertyKey) => {
@@ -59,24 +186,114 @@ export function uiprop(propName = undefined, stringify = false) {
     };
 }
 /**
- * Adds the UIListProp definition as metadata to the property, allowing it to be read by any {@link RenderStrategy}
+ * @description Decorator that maps a model property to a UI component property
+ * @summary Specifies how a property should be passed to a UI component
+ * This decorator allows you to define how a model property should be mapped to
+ * a property of the UI component when rendering. It requires the class to be
+ * decorated with @uimodel.
+ *
+ * @param {string} [propName] The name of the property to pass to the component (defaults to the property key)
+ * @param {boolean} [stringify=false] Whether to stringify the property value
+ * @return {Function} A property decorator function
+ *
+ * @function uiprop
+ * @category Property Decorators
+ *
+ * @example
+ * // Map model properties to component properties
+ * @uimodel('user-profile')
+ * class UserProfile {
+ *   @attribute()
+ *   @uiprop() // Will be passed as 'fullName' to the component
+ *   fullName: string;
+ *
+ *   @attribute()
+ *   @uiprop('userEmail') // Will be passed as 'userEmail' to the component
+ *   email: string;
+ *
+ *   @attribute()
+ *   @uiprop('userData', true) // Will be passed as stringified JSON
+ *   userData: Record<string, any>;
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uiprop
+ *   participant RenderingEngine
+ *   participant Component
+ *   Model->>uiprop: Apply to property
+ *   uiprop->>Model: Add prop metadata
+ *   RenderingEngine->>Model: Get prop metadata
+ *   Model->>RenderingEngine: Return prop name and stringify flag
+ *   RenderingEngine->>Component: Pass property with specified name
+ */
+export function uichild(propName = undefined, stringify = false, tag) {
+    return (target, propertyKey) => {
+        const metadata = {
+            name: propName || propertyKey,
+            stringify: stringify,
+            tag: tag,
+        };
+        propMetadata(RenderingEngine.key(UIKeys.CHILD), metadata)(target, propertyKey);
+    };
+}
+/**
+ * @description Decorator that maps a model property to a list item component
+ * @summary Specifies how a property should be rendered in a list context
+ * This decorator allows you to define how a model property containing a list
+ * should be rendered. It requires the class to be decorated with @uilistitem.
+ *
+ * @param {string} [propName] The name of the property to pass to the list component (defaults to the property key)
+ * @param {Record<string, any>} [props] Additional properties to pass to the list container
+ * @return {Function} A property decorator function
+ *
+ * @function uilistprop
+ * @category Property Decorators
+ *
+ * @example
+ * // Define a list property with custom rendering
+ * @uimodel('todo-list')
+ * class TodoList {
+ *   @attribute()
+ *   title: string;
  *
- * this requires a '@uilistitem' with a defined tag
+ *   @attribute()
+ *   @uilistprop('items', { class: 'todo-items-container' })
+ *   items: TodoItem[];
+ * }
  *
- * @param {string} [propName] the property name that will be passed to the component. defaults to the PropertyKey
+ * @uilistitem('li', { class: 'todo-item' })
+ * class TodoItem extends Model {
+ *   @attribute()
+ *   text: string;
  *
- * @decorator uiprop
+ *   @attribute()
+ *   completed: boolean;
+ * }
  *
- * @category Decorators
- * @subcategory ui-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant uilistprop
+ *   participant RenderingEngine
+ *   participant ListContainer
+ *   participant ListItems
+ *   Model->>uilistprop: Apply to property
+ *   uilistprop->>Model: Add list prop metadata
+ *   RenderingEngine->>Model: Get list prop metadata
+ *   Model->>RenderingEngine: Return prop name and container props
+ *   RenderingEngine->>ListContainer: Create container with props
+ *   RenderingEngine->>ListItems: Render each item using @uilistitem
+ *   ListContainer->>RenderingEngine: Return rendered list
  */
 export function uilistprop(propName = undefined, props) {
     return (target, propertyKey) => {
         const metadata = {
             name: propName || propertyKey,
-            props: props || {}
+            props: props || {},
         };
         propMetadata(RenderingEngine.key(UIKeys.UILISTPROP), metadata)(target, propertyKey);
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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 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 uichild(\n  propName: string | undefined = undefined,\n  stringify: boolean = false,\n  tag?: string\n) {\n  return (target: any, propertyKey: string) => {\n    const metadata: UIPropMetadata = {\n      name: propName || propertyKey,\n      stringify: stringify,\n      tag: tag,\n    } as any;\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"]}

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

@@ -1,4 +1,32 @@
 import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when a rendering operation fails
+ * @summary Specialized error for rendering failures in UI components
+ * This error is thrown when the rendering engine encounters an error while
+ * attempting to render a UI component or model.
+ *
+ * @param {string|Error} msg The error message or original error
+ *
+ * @class RenderingError
+ * @extends BaseError
+ * @category Errors
+ *
+ * @example
+ * // Throwing a rendering error
+ * try {
+ *   // Rendering code that might fail
+ *   if (!component.canRender()) {
+ *     throw new RenderingError('Component cannot be rendered');
+ *   }
+ * } catch (error) {
+ *   console.error('Rendering failed:', error.message);
+ * }
+ */
 export declare class RenderingError extends BaseError {
+    /**
+     * @description Creates a new RenderingError instance
+     * @summary Initializes the error with a message or original error
+     * @param {string|Error} msg The error message or original error
+     */
     constructor(msg: string | Error);
 }

package/lib/esm/ui/errors.js

@@ -1,7 +1,35 @@
 import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when a rendering operation fails
+ * @summary Specialized error for rendering failures in UI components
+ * This error is thrown when the rendering engine encounters an error while
+ * attempting to render a UI component or model.
+ *
+ * @param {string|Error} msg The error message or original error
+ *
+ * @class RenderingError
+ * @extends BaseError
+ * @category Errors
+ *
+ * @example
+ * // Throwing a rendering error
+ * try {
+ *   // Rendering code that might fail
+ *   if (!component.canRender()) {
+ *     throw new RenderingError('Component cannot be rendered');
+ *   }
+ * } catch (error) {
+ *   console.error('Rendering failed:', error.message);
+ * }
+ */
 export class RenderingError extends BaseError {
+    /**
+     * @description Creates a new RenderingError instance
+     * @summary Initializes the error with a message or original error
+     * @param {string|Error} msg The error message or original error
+     */
     constructor(msg) {
         super(RenderingError.name, msg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3VpL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEQsTUFBTSxPQUFPLGNBQWUsU0FBUSxTQUFTO0lBQzNDLFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCBjbGFzcyBSZW5kZXJpbmdFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihSZW5kZXJpbmdFcnJvci5uYW1lLCBtc2cpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3VpL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFDSCxNQUFNLE9BQU8sY0FBZSxTQUFRLFNBQVM7SUFDM0M7Ozs7T0FJRztJQUNILFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEVycm9yIHRocm93biB3aGVuIGEgcmVuZGVyaW5nIG9wZXJhdGlvbiBmYWlsc1xuICogQHN1bW1hcnkgU3BlY2lhbGl6ZWQgZXJyb3IgZm9yIHJlbmRlcmluZyBmYWlsdXJlcyBpbiBVSSBjb21wb25lbnRzXG4gKiBUaGlzIGVycm9yIGlzIHRocm93biB3aGVuIHRoZSByZW5kZXJpbmcgZW5naW5lIGVuY291bnRlcnMgYW4gZXJyb3Igd2hpbGVcbiAqIGF0dGVtcHRpbmcgdG8gcmVuZGVyIGEgVUkgY29tcG9uZW50IG9yIG1vZGVsLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfEVycm9yfSBtc2cgVGhlIGVycm9yIG1lc3NhZ2Ugb3Igb3JpZ2luYWwgZXJyb3JcbiAqXG4gKiBAY2xhc3MgUmVuZGVyaW5nRXJyb3JcbiAqIEBleHRlbmRzIEJhc2VFcnJvclxuICogQGNhdGVnb3J5IEVycm9yc1xuICpcbiAqIEBleGFtcGxlXG4gKiAvLyBUaHJvd2luZyBhIHJlbmRlcmluZyBlcnJvclxuICogdHJ5IHtcbiAqICAgLy8gUmVuZGVyaW5nIGNvZGUgdGhhdCBtaWdodCBmYWlsXG4gKiAgIGlmICghY29tcG9uZW50LmNhblJlbmRlcigpKSB7XG4gKiAgICAgdGhyb3cgbmV3IFJlbmRlcmluZ0Vycm9yKCdDb21wb25lbnQgY2Fubm90IGJlIHJlbmRlcmVkJyk7XG4gKiAgIH1cbiAqIH0gY2F0Y2ggKGVycm9yKSB7XG4gKiAgIGNvbnNvbGUuZXJyb3IoJ1JlbmRlcmluZyBmYWlsZWQ6JywgZXJyb3IubWVzc2FnZSk7XG4gKiB9XG4gKi9cbmV4cG9ydCBjbGFzcyBSZW5kZXJpbmdFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gQ3JlYXRlcyBhIG5ldyBSZW5kZXJpbmdFcnJvciBpbnN0YW5jZVxuICAgKiBAc3VtbWFyeSBJbml0aWFsaXplcyB0aGUgZXJyb3Igd2l0aCBhIG1lc3NhZ2Ugb3Igb3JpZ2luYWwgZXJyb3JcbiAgICogQHBhcmFtIHtzdHJpbmd8RXJyb3J9IG1zZyBUaGUgZXJyb3IgbWVzc2FnZSBvciBvcmlnaW5hbCBlcnJvclxuICAgKi9cbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcgfCBFcnJvcikge1xuICAgIHN1cGVyKFJlbmRlcmluZ0Vycm9yLm5hbWUsIG1zZyk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,17 @@
+/**
+ * @description Class representing an event handler
+ * @summary Defines the structure for handling events in the UI decorators system
+ * This class provides a foundation for managing and processing events that occur
+ * within the UI components generated by the decorators.
+ * @class EventHandler
+ * @memberOf module:ui-decorators/ui
+ */
+export declare class EventHandler {
+    /**
+     * @description Creates an instance of EventHandler
+     * @summary Initializes a new EventHandler object
+     * This constructor currently doesn't take any parameters, but it can be
+     * extended in the future to accept configuration options if needed.
+     */
+    constructor();
+}

package/lib/esm/ui/handlers.js

@@ -0,0 +1,18 @@
+/**
+ * @description Class representing an event handler
+ * @summary Defines the structure for handling events in the UI decorators system
+ * This class provides a foundation for managing and processing events that occur
+ * within the UI components generated by the decorators.
+ * @class EventHandler
+ * @memberOf module:ui-decorators/ui
+ */
+export class EventHandler {
+    /**
+     * @description Creates an instance of EventHandler
+     * @summary Initializes a new EventHandler object
+     * This constructor currently doesn't take any parameters, but it can be
+     * extended in the future to accept configuration options if needed.
+     */
+    constructor() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdWkvaGFuZGxlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE1BQU0sT0FBTyxZQUFZO0lBQ3ZCOzs7OztPQUtHO0lBQ0gsZ0JBQWUsQ0FBQztDQUNqQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIENsYXNzIHJlcHJlc2VudGluZyBhbiBldmVudCBoYW5kbGVyXG4gKiBAc3VtbWFyeSBEZWZpbmVzIHRoZSBzdHJ1Y3R1cmUgZm9yIGhhbmRsaW5nIGV2ZW50cyBpbiB0aGUgVUkgZGVjb3JhdG9ycyBzeXN0ZW1cbiAqIFRoaXMgY2xhc3MgcHJvdmlkZXMgYSBmb3VuZGF0aW9uIGZvciBtYW5hZ2luZyBhbmQgcHJvY2Vzc2luZyBldmVudHMgdGhhdCBvY2N1clxuICogd2l0aGluIHRoZSBVSSBjb21wb25lbnRzIGdlbmVyYXRlZCBieSB0aGUgZGVjb3JhdG9ycy5cbiAqIEBjbGFzcyBFdmVudEhhbmRsZXJcbiAqIEBtZW1iZXJPZiBtb2R1bGU6dWktZGVjb3JhdG9ycy91aVxuICovXG5leHBvcnQgY2xhc3MgRXZlbnRIYW5kbGVyIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBDcmVhdGVzIGFuIGluc3RhbmNlIG9mIEV2ZW50SGFuZGxlclxuICAgKiBAc3VtbWFyeSBJbml0aWFsaXplcyBhIG5ldyBFdmVudEhhbmRsZXIgb2JqZWN0XG4gICAqIFRoaXMgY29uc3RydWN0b3IgY3VycmVudGx5IGRvZXNuJ3QgdGFrZSBhbnkgcGFyYW1ldGVycywgYnV0IGl0IGNhbiBiZVxuICAgKiBleHRlbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGFjY2VwdCBjb25maWd1cmF0aW9uIG9wdGlvbnMgaWYgbmVlZGVkLlxuICAgKi9cbiAgY29uc3RydWN0b3IoKSB7fVxufSJdfQ==

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

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

package/lib/esm/ui/index.js

@@ -1,12 +1,9 @@
-/**
- * @namespace ui-decorators.ui
- * @memberOf ui-decorators
- */
 export * from "./constants";
 export * from "./decorators";
 export * from "./errors";
 export * from "./interfaces";
 export * from "./Rendering";
 export * from "./types";
+export * from "./handlers";
 export * from "./utils";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdWkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBuYW1lc3BhY2UgdWktZGVjb3JhdG9ycy51aVxuICogQG1lbWJlck9mIHVpLWRlY29yYXRvcnNcbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmVuZGVyaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdWkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmVuZGVyaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaGFuZGxlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG4iXX0=

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

@@ -1,5 +1,30 @@
+/**
+ * @description Interfaces for UI form components
+ * @summary Defines interfaces for form fields with CRUD operations
+ * This module contains interfaces that extend basic field properties with
+ * CRUD operation information for form generation.
+ * @module ui/interfaces
+ * @memberOf module:ui-decorators
+ */
 import { FieldProperties } from "./types";
 import { CrudOperations } from "@decaf-ts/db-decorators";
+/**
+ * @description Form field interface with CRUD operation information
+ * @summary Extends basic field properties with a specific CRUD operation
+ * This interface represents a form field that is associated with a specific
+ * CRUD operation (Create, Read, Update, Delete). It combines all the standard
+ * field properties with an operation property.
+ *
+ * @interface CrudFormField
+ * @extends FieldProperties
+ * @memberOf module:ui-decorators
+ *
+ * @property {CrudOperations} operation - The CRUD operation associated with this field
+ */
 export interface CrudFormField extends FieldProperties {
+    /**
+     * @description The CRUD operation associated with this field
+     * @summary Specifies which operation (Create, Read, Update, Delete) this field is for
+     */
     operation: CrudOperations;
 }

package/lib/esm/ui/interfaces.js

@@ -1,2 +1,10 @@
+/**
+ * @description Interfaces for UI form components
+ * @summary Defines interfaces for form fields with CRUD operations
+ * This module contains interfaces that extend basic field properties with
+ * CRUD operation information for form generation.
+ * @module ui/interfaces
+ * @memberOf module:ui-decorators
+ */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91aS9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGaWVsZFByb3BlcnRpZXMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHsgQ3J1ZE9wZXJhdGlvbnMgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuZXhwb3J0IGludGVyZmFjZSBDcnVkRm9ybUZpZWxkIGV4dGVuZHMgRmllbGRQcm9wZXJ0aWVzIHtcbiAgb3BlcmF0aW9uOiBDcnVkT3BlcmF0aW9ucztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91aS9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBJbnRlcmZhY2VzIGZvciBVSSBmb3JtIGNvbXBvbmVudHNcbiAqIEBzdW1tYXJ5IERlZmluZXMgaW50ZXJmYWNlcyBmb3IgZm9ybSBmaWVsZHMgd2l0aCBDUlVEIG9wZXJhdGlvbnNcbiAqIFRoaXMgbW9kdWxlIGNvbnRhaW5zIGludGVyZmFjZXMgdGhhdCBleHRlbmQgYmFzaWMgZmllbGQgcHJvcGVydGllcyB3aXRoXG4gKiBDUlVEIG9wZXJhdGlvbiBpbmZvcm1hdGlvbiBmb3IgZm9ybSBnZW5lcmF0aW9uLlxuICogQG1vZHVsZSB1aS9pbnRlcmZhY2VzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnVpLWRlY29yYXRvcnNcbiAqL1xuXG5pbXBvcnQgeyBGaWVsZFByb3BlcnRpZXMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHsgQ3J1ZE9wZXJhdGlvbnMgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gRm9ybSBmaWVsZCBpbnRlcmZhY2Ugd2l0aCBDUlVEIG9wZXJhdGlvbiBpbmZvcm1hdGlvblxuICogQHN1bW1hcnkgRXh0ZW5kcyBiYXNpYyBmaWVsZCBwcm9wZXJ0aWVzIHdpdGggYSBzcGVjaWZpYyBDUlVEIG9wZXJhdGlvblxuICogVGhpcyBpbnRlcmZhY2UgcmVwcmVzZW50cyBhIGZvcm0gZmllbGQgdGhhdCBpcyBhc3NvY2lhdGVkIHdpdGggYSBzcGVjaWZpY1xuICogQ1JVRCBvcGVyYXRpb24gKENyZWF0ZSwgUmVhZCwgVXBkYXRlLCBEZWxldGUpLiBJdCBjb21iaW5lcyBhbGwgdGhlIHN0YW5kYXJkXG4gKiBmaWVsZCBwcm9wZXJ0aWVzIHdpdGggYW4gb3BlcmF0aW9uIHByb3BlcnR5LlxuICpcbiAqIEBpbnRlcmZhY2UgQ3J1ZEZvcm1GaWVsZFxuICogQGV4dGVuZHMgRmllbGRQcm9wZXJ0aWVzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnVpLWRlY29yYXRvcnNcbiAqXG4gKiBAcHJvcGVydHkge0NydWRPcGVyYXRpb25zfSBvcGVyYXRpb24gLSBUaGUgQ1JVRCBvcGVyYXRpb24gYXNzb2NpYXRlZCB3aXRoIHRoaXMgZmllbGRcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDcnVkRm9ybUZpZWxkIGV4dGVuZHMgRmllbGRQcm9wZXJ0aWVzIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBUaGUgQ1JVRCBvcGVyYXRpb24gYXNzb2NpYXRlZCB3aXRoIHRoaXMgZmllbGRcbiAgICogQHN1bW1hcnkgU3BlY2lmaWVzIHdoaWNoIG9wZXJhdGlvbiAoQ3JlYXRlLCBSZWFkLCBVcGRhdGUsIERlbGV0ZSkgdGhpcyBmaWVsZCBpcyBmb3JcbiAgICovXG4gIG9wZXJhdGlvbjogQ3J1ZE9wZXJhdGlvbnM7XG59XG4iXX0=