@decaf-ts/ui-decorators 0.5.9 → 0.5.11

package/lib/esm/ui/constants.js

@@ -1,7 +1,56 @@
+/**
+ * @description Constants and enums for UI rendering and validation
+ * @summary Defines keys, mappings, and HTML5 input types for UI components
+ * This module provides constants used throughout the UI decorators library for
+ * rendering, validation, and HTML element generation.
+ * @module ui/constants
+ * @memberOf module:ui-decorators
+ */
 import { DateValidator, DiffValidator, EmailValidator, EqualsValidator, GreaterThanOrEqualValidator, GreaterThanValidator, LessThanOrEqualValidator, LessThanValidator, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, ModelKeys, PasswordValidator, PatternValidator, RequiredValidator, StepValidator, URLValidator, ValidationKeys, } from "@decaf-ts/decorator-validation";
 /**
- * @enum UIKeys
- * @category Constants
+ * @description Key constants used for UI metadata and rendering
+ * @summary Collection of string constants used as keys for UI-related metadata
+ * These keys are used throughout the library to store and retrieve metadata related to
+ * UI models, elements, properties, and validation rules.
+ *
+ * @typedef {Object} UIKeysType
+ * @property {string} REFLECT - Base reflection key for UI metadata
+ * @property {string} UIMODEL - Key for UI model metadata
+ * @property {string} RENDERED_BY - Key for specifying rendering engine
+ * @property {string} ELEMENT - Key for element metadata
+ * @property {string} PROP - Key for property metadata
+ * @property {string} NAME - Key for name attribute
+ * @property {string} NAME_PREFIX - Prefix for input names
+ * @property {string} CUSTOM_PROPS - Key for custom validation properties
+ * @property {string} UILISTITEM - Key for list item metadata
+ * @property {string} UILISTPROP - Key for list property metadata
+ * @property {string} TYPE - Key for type metadata
+ * @property {string} SUB_TYPE - Key for subtype metadata
+ * @property {string} HIDDEN - Key for hidden attribute
+ * @property {string} FORMAT - Key for format metadata
+ * @property {string} READ_ONLY - Key for readonly attribute
+ * @property {string} REQUIRED - Key for required validation
+ * @property {string} MIN - Key for minimum value validation
+ * @property {string} MIN_LENGTH - Key for minimum length validation
+ * @property {string} MAX - Key for maximum value validation
+ * @property {string} MAX_LENGTH - Key for maximum length validation
+ * @property {string} PATTERN - Key for pattern validation
+ * @property {string} URL - Key for URL validation
+ * @property {string} STEP - Key for step validation
+ * @property {string} DATE - Key for date validation
+ * @property {string} EMAIL - Key for email validation
+ * @property {string} PASSWORD - Key for password validation
+ * @property {string} EQUALS - Key for equality validation
+ * @property {string} DIFF - Key for difference validation
+ * @property {string} LESS_THAN - Key for less than validation
+ * @property {string} LESS_THAN_OR_EQUAL - Key for less than or equal validation
+ * @property {string} GREATER_THAN - Key for greater than validation
+ * @property {string} GREATER_THAN_OR_EQUAL - Key for greater than or equal validation
+ *
+ * @const UIKeys
+ * @type {UIKeysType}
+ * @readonly
+ * @memberOf module:ui-decorators
  */
 export const UIKeys = {
     REFLECT: `${ModelKeys.REFLECT}.ui.`,
@@ -9,11 +58,13 @@ export const UIKeys = {
     RENDERED_BY: "rendered-by",
     ELEMENT: "element",
     PROP: "prop",
+    CHILD: "child",
     NAME: "name",
     NAME_PREFIX: "input-",
     CUSTOM_PROPS: "customValidationProps",
     UILISTITEM: "uilistitem",
     UILISTPROP: "listprop",
+    HANDLERS: "handlers",
     TYPE: "type",
     SUB_TYPE: "subtype",
     HIDDEN: "hidden",
@@ -37,6 +88,23 @@ export const UIKeys = {
     GREATER_THAN: ValidationKeys.GREATER_THAN,
     GREATER_THAN_OR_EQUAL: ValidationKeys.GREATER_THAN_OR_EQUAL,
 };
+/**
+ * @description Mapping of input types to their corresponding validators
+ * @summary Maps special input types to their validator classes
+ * This constant maps input types like email, URL, date, and password to their
+ * corresponding validator classes from the decorator-validation library.
+ *
+ * @typedef {Object.<string, Constructor<Validator>>} ValidatableByTypeMap
+ * @property {Constructor<EmailValidator>} email - Validator for email inputs
+ * @property {Constructor<URLValidator>} url - Validator for URL inputs
+ * @property {Constructor<DateValidator>} date - Validator for date inputs
+ * @property {Constructor<PasswordValidator>} password - Validator for password inputs
+ *
+ * @const ValidatableByType
+ * @type {ValidatableByTypeMap}
+ * @readonly
+ * @memberOf module:ui-decorators
+ */
 export const ValidatableByType = {
     [UIKeys.EMAIL]: EmailValidator,
     [UIKeys.URL]: URLValidator,
@@ -44,9 +112,30 @@ export const ValidatableByType = {
     [UIKeys.PASSWORD]: PasswordValidator,
 };
 /**
- * @constant ValidatableByAttribute
+ * @description Mapping of validation attributes to their corresponding validators
+ * @summary Maps HTML validation attributes to their validator classes
+ * This constant maps HTML validation attributes like required, min, max, pattern, etc.
+ * to their corresponding validator classes from the decorator-validation library.
  *
- * @memberOf ui-decorators-web.ui
+ * @typedef {Object.<string, Constructor<Validator>>} ValidatableByAttributeMap
+ * @property {Constructor<RequiredValidator>} required - Validator for required fields
+ * @property {Constructor<MinValidator>} min - Validator for minimum value
+ * @property {Constructor<MaxValidator>} max - Validator for maximum value
+ * @property {Constructor<StepValidator>} step - Validator for step value
+ * @property {Constructor<MinLengthValidator>} minlength - Validator for minimum length
+ * @property {Constructor<MaxLengthValidator>} maxlength - Validator for maximum length
+ * @property {Constructor<PatternValidator>} pattern - Validator for regex pattern
+ * @property {Constructor<EqualsValidator>} equals - Validator for equality
+ * @property {Constructor<DiffValidator>} diff - Validator for difference
+ * @property {Constructor<LessThanValidator>} lessthan - Validator for less than comparison
+ * @property {Constructor<LessThanOrEqualValidator>} lessthanorequal - Validator for less than or equal comparison
+ * @property {Constructor<GreaterThanValidator>} greaterthan - Validator for greater than comparison
+ * @property {Constructor<GreaterThanOrEqualValidator>} greaterthanorequal - Validator for greater than or equal comparison
+ *
+ * @const ValidatableByAttribute
+ * @type {ValidatableByAttributeMap}
+ * @readonly
+ * @memberOf module:ui-decorators
  */
 export const ValidatableByAttribute = {
     [UIKeys.REQUIRED]: RequiredValidator,
@@ -63,7 +152,52 @@ export const ValidatableByAttribute = {
     [UIKeys.GREATER_THAN]: GreaterThanValidator,
     [UIKeys.GREATER_THAN_OR_EQUAL]: GreaterThanOrEqualValidator,
 };
+/**
+ * @description Standard date format string for HTML5 date inputs
+ * @summary Format string for HTML5 date inputs (yyyy-MM-dd)
+ * This constant defines the standard date format string used for HTML5 date inputs.
+ *
+ * @const HTML5DateFormat
+ * @type {string}
+ * @readonly
+ * @memberOf module:ui-decorators
+ */
 export const HTML5DateFormat = "yyyy-MM-dd";
+/**
+ * @description Collection of HTML5 input type values
+ * @summary Maps input type constants to their HTML attribute values
+ * This constant provides a mapping of input type constants to their corresponding
+ * HTML attribute values for use in form elements.
+ *
+ * @typedef {Object} HTML5InputTypesMap
+ * @property {string} BUTTON - Button input type
+ * @property {string} CHECKBOX - Checkbox input type
+ * @property {string} COLOR - Color picker input type
+ * @property {string} DATE - Date picker input type
+ * @property {string} DATETIME_LOCAL - Local datetime picker input type
+ * @property {string} EMAIL - Email input type with validation
+ * @property {string} FILE - File upload input type
+ * @property {string} HIDDEN - Hidden input type
+ * @property {string} IMAGE - Image input type
+ * @property {string} MONTH - Month picker input type
+ * @property {string} NUMBER - Numeric input type
+ * @property {string} PASSWORD - Password input type with masked text
+ * @property {string} RADIO - Radio button input type
+ * @property {string} RANGE - Range slider input type
+ * @property {string} RESET - Form reset button input type
+ * @property {string} SEARCH - Search input type
+ * @property {string} SUBMIT - Form submit button input type
+ * @property {string} TEL - Telephone number input type
+ * @property {string} TEXT - Basic text input type
+ * @property {string} TIME - Time picker input type
+ * @property {string} URL - URL input type with validation
+ * @property {string} WEEK - Week picker input type
+ *
+ * @const HTML5InputTypes
+ * @type {HTML5InputTypesMap}
+ * @readonly
+ * @memberOf module:ui-decorators
+ */
 export const HTML5InputTypes = {
     BUTTON: "button",
     CHECKBOX: "checkbox",
@@ -88,8 +222,19 @@ export const HTML5InputTypes = {
     URL: UIKeys.URL,
     WEEK: "week",
 };
+/**
+ * @description Array of HTML5 input types that use checkboxes
+ * @summary List of input types that represent checkable controls
+ * This constant defines an array of HTML5 input types that represent
+ * checkable controls (checkbox and radio).
+ *
+ * @const HTML5CheckTypes
+ * @type {string[]}
+ * @readonly
+ * @memberOf module:ui-decorators
+ */
 export const HTML5CheckTypes = [
     HTML5InputTypes.CHECKBOX,
     HTML5InputTypes.RADIO,
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/ui/constants.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Constructor,\n  DateValidator,\n  DiffValidator,\n  EmailValidator,\n  EqualsValidator,\n  GreaterThanOrEqualValidator,\n  GreaterThanValidator,\n  LessThanOrEqualValidator,\n  LessThanValidator,\n  MaxLengthValidator,\n  MaxValidator,\n  MinLengthValidator,\n  MinValidator,\n  ModelKeys,\n  PasswordValidator,\n  PatternValidator,\n  RequiredValidator,\n  StepValidator,\n  URLValidator,\n  ValidationKeys,\n  Validator,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @enum UIKeys\n * @category Constants\n */\nexport const UIKeys = {\n  REFLECT: `${ModelKeys.REFLECT}.ui.`,\n  UIMODEL: \"uimodel\",\n  RENDERED_BY: \"rendered-by\",\n  ELEMENT: \"element\",\n  PROP: \"prop\",\n  NAME: \"name\",\n  NAME_PREFIX: \"input-\",\n  CUSTOM_PROPS: \"customValidationProps\",\n\n  UILISTITEM: \"uilistitem\",\n  UILISTPROP: \"listprop\",\n\n  TYPE: \"type\",\n  SUB_TYPE: \"subtype\",\n\n  HIDDEN: \"hidden\",\n  FORMAT: \"format\",\n\n  READ_ONLY: \"readonly\",\n  REQUIRED: ValidationKeys.REQUIRED,\n  MIN: ValidationKeys.MIN,\n  MIN_LENGTH: ValidationKeys.MIN_LENGTH,\n  MAX: ValidationKeys.MAX,\n  MAX_LENGTH: ValidationKeys.MAX_LENGTH,\n  PATTERN: ValidationKeys.PATTERN,\n  URL: ValidationKeys.URL,\n  STEP: ValidationKeys.STEP,\n  DATE: ValidationKeys.DATE,\n  EMAIL: ValidationKeys.EMAIL,\n  PASSWORD: ValidationKeys.PASSWORD,\n  EQUALS: ValidationKeys.EQUALS,\n  DIFF: ValidationKeys.DIFF,\n  LESS_THAN: ValidationKeys.LESS_THAN,\n  LESS_THAN_OR_EQUAL: ValidationKeys.LESS_THAN_OR_EQUAL,\n  GREATER_THAN: ValidationKeys.GREATER_THAN,\n  GREATER_THAN_OR_EQUAL: ValidationKeys.GREATER_THAN_OR_EQUAL,\n};\n\nexport const ValidatableByType: Record<string, Constructor<Validator>> = {\n  [UIKeys.EMAIL]: EmailValidator,\n  [UIKeys.URL]: URLValidator,\n  [UIKeys.DATE]: DateValidator,\n  [UIKeys.PASSWORD]: PasswordValidator,\n};\n\n/**\n * @constant ValidatableByAttribute\n *\n * @memberOf ui-decorators-web.ui\n */\nexport const ValidatableByAttribute: Record<string, Constructor<Validator>> = {\n  [UIKeys.REQUIRED]: RequiredValidator,\n  [UIKeys.MIN]: MinValidator,\n  [UIKeys.MAX]: MaxValidator,\n  [UIKeys.STEP]: StepValidator,\n  [UIKeys.MIN_LENGTH]: MinLengthValidator,\n  [UIKeys.MAX_LENGTH]: MaxLengthValidator,\n  [UIKeys.PATTERN]: PatternValidator,\n  [UIKeys.EQUALS]: EqualsValidator,\n  [UIKeys.DIFF]: DiffValidator,\n  [UIKeys.LESS_THAN]: LessThanValidator,\n  [UIKeys.LESS_THAN_OR_EQUAL]: LessThanOrEqualValidator,\n  [UIKeys.GREATER_THAN]: GreaterThanValidator,\n  [UIKeys.GREATER_THAN_OR_EQUAL]: GreaterThanOrEqualValidator,\n};\n\nexport const HTML5DateFormat = \"yyyy-MM-dd\";\n\nexport const HTML5InputTypes = {\n  BUTTON: \"button\",\n  CHECKBOX: \"checkbox\",\n  COLOR: \"color\",\n  DATE: UIKeys.DATE,\n  DATETIME_LOCAL: \"datetime-local\",\n  EMAIL: UIKeys.EMAIL,\n  FILE: \"file\",\n  HIDDEN: \"hidden\",\n  IMAGE: \"image\",\n  MONTH: \"month\",\n  NUMBER: \"number\",\n  PASSWORD: UIKeys.PASSWORD,\n  RADIO: \"radio\",\n  RANGE: \"range\",\n  RESET: \"reset\",\n  SEARCH: \"search\",\n  SUBMIT: \"submit\",\n  TEL: \"tel\",\n  TEXT: \"text\",\n  TIME: \"time\",\n  URL: UIKeys.URL,\n  WEEK: \"week\",\n};\n\nexport const HTML5CheckTypes = [\n  HTML5InputTypes.CHECKBOX,\n  HTML5InputTypes.RADIO,\n];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/ui/constants.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @description Constants and enums for UI rendering and validation\n * @summary Defines keys, mappings, and HTML5 input types for UI components\n * This module provides constants used throughout the UI decorators library for\n * rendering, validation, and HTML element generation.\n * @module ui/constants\n * @memberOf module:ui-decorators\n */\n\nimport {\n  Constructor,\n  DateValidator,\n  DiffValidator,\n  EmailValidator,\n  EqualsValidator,\n  GreaterThanOrEqualValidator,\n  GreaterThanValidator,\n  LessThanOrEqualValidator,\n  LessThanValidator,\n  MaxLengthValidator,\n  MaxValidator,\n  MinLengthValidator,\n  MinValidator,\n  ModelKeys,\n  PasswordValidator,\n  PatternValidator,\n  RequiredValidator,\n  StepValidator,\n  URLValidator,\n  ValidationKeys,\n  Validator,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Key constants used for UI metadata and rendering\n * @summary Collection of string constants used as keys for UI-related metadata\n * These keys are used throughout the library to store and retrieve metadata related to\n * UI models, elements, properties, and validation rules.\n *\n * @typedef {Object} UIKeysType\n * @property {string} REFLECT - Base reflection key for UI metadata\n * @property {string} UIMODEL - Key for UI model metadata\n * @property {string} RENDERED_BY - Key for specifying rendering engine\n * @property {string} ELEMENT - Key for element metadata\n * @property {string} PROP - Key for property metadata\n * @property {string} NAME - Key for name attribute\n * @property {string} NAME_PREFIX - Prefix for input names\n * @property {string} CUSTOM_PROPS - Key for custom validation properties\n * @property {string} UILISTITEM - Key for list item metadata\n * @property {string} UILISTPROP - Key for list property metadata\n * @property {string} TYPE - Key for type metadata\n * @property {string} SUB_TYPE - Key for subtype metadata\n * @property {string} HIDDEN - Key for hidden attribute\n * @property {string} FORMAT - Key for format metadata\n * @property {string} READ_ONLY - Key for readonly attribute\n * @property {string} REQUIRED - Key for required validation\n * @property {string} MIN - Key for minimum value validation\n * @property {string} MIN_LENGTH - Key for minimum length validation\n * @property {string} MAX - Key for maximum value validation\n * @property {string} MAX_LENGTH - Key for maximum length validation\n * @property {string} PATTERN - Key for pattern validation\n * @property {string} URL - Key for URL validation\n * @property {string} STEP - Key for step validation\n * @property {string} DATE - Key for date validation\n * @property {string} EMAIL - Key for email validation\n * @property {string} PASSWORD - Key for password validation\n * @property {string} EQUALS - Key for equality validation\n * @property {string} DIFF - Key for difference validation\n * @property {string} LESS_THAN - Key for less than validation\n * @property {string} LESS_THAN_OR_EQUAL - Key for less than or equal validation\n * @property {string} GREATER_THAN - Key for greater than validation\n * @property {string} GREATER_THAN_OR_EQUAL - Key for greater than or equal validation\n *\n * @const UIKeys\n * @type {UIKeysType}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const UIKeys = {\n  REFLECT: `${ModelKeys.REFLECT}.ui.`,\n  UIMODEL: \"uimodel\",\n  RENDERED_BY: \"rendered-by\",\n  ELEMENT: \"element\",\n  PROP: \"prop\",\n  CHILD: \"child\",\n  NAME: \"name\",\n  NAME_PREFIX: \"input-\",\n  CUSTOM_PROPS: \"customValidationProps\",\n\n  UILISTITEM: \"uilistitem\",\n  UILISTPROP: \"listprop\",\n  HANDLERS: \"handlers\",\n\n  TYPE: \"type\",\n  SUB_TYPE: \"subtype\",\n\n  HIDDEN: \"hidden\",\n  FORMAT: \"format\",\n\n  READ_ONLY: \"readonly\",\n  REQUIRED: ValidationKeys.REQUIRED,\n  MIN: ValidationKeys.MIN,\n  MIN_LENGTH: ValidationKeys.MIN_LENGTH,\n  MAX: ValidationKeys.MAX,\n  MAX_LENGTH: ValidationKeys.MAX_LENGTH,\n  PATTERN: ValidationKeys.PATTERN,\n  URL: ValidationKeys.URL,\n  STEP: ValidationKeys.STEP,\n  DATE: ValidationKeys.DATE,\n  EMAIL: ValidationKeys.EMAIL,\n  PASSWORD: ValidationKeys.PASSWORD,\n  EQUALS: ValidationKeys.EQUALS,\n  DIFF: ValidationKeys.DIFF,\n  LESS_THAN: ValidationKeys.LESS_THAN,\n  LESS_THAN_OR_EQUAL: ValidationKeys.LESS_THAN_OR_EQUAL,\n  GREATER_THAN: ValidationKeys.GREATER_THAN,\n  GREATER_THAN_OR_EQUAL: ValidationKeys.GREATER_THAN_OR_EQUAL,\n};\n\n/**\n * @description Mapping of input types to their corresponding validators\n * @summary Maps special input types to their validator classes\n * This constant maps input types like email, URL, date, and password to their\n * corresponding validator classes from the decorator-validation library.\n *\n * @typedef {Object.<string, Constructor<Validator>>} ValidatableByTypeMap\n * @property {Constructor<EmailValidator>} email - Validator for email inputs\n * @property {Constructor<URLValidator>} url - Validator for URL inputs\n * @property {Constructor<DateValidator>} date - Validator for date inputs\n * @property {Constructor<PasswordValidator>} password - Validator for password inputs\n *\n * @const ValidatableByType\n * @type {ValidatableByTypeMap}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const ValidatableByType: Record<string, Constructor<Validator>> = {\n  [UIKeys.EMAIL]: EmailValidator,\n  [UIKeys.URL]: URLValidator,\n  [UIKeys.DATE]: DateValidator,\n  [UIKeys.PASSWORD]: PasswordValidator,\n};\n\n/**\n * @description Mapping of validation attributes to their corresponding validators\n * @summary Maps HTML validation attributes to their validator classes\n * This constant maps HTML validation attributes like required, min, max, pattern, etc.\n * to their corresponding validator classes from the decorator-validation library.\n *\n * @typedef {Object.<string, Constructor<Validator>>} ValidatableByAttributeMap\n * @property {Constructor<RequiredValidator>} required - Validator for required fields\n * @property {Constructor<MinValidator>} min - Validator for minimum value\n * @property {Constructor<MaxValidator>} max - Validator for maximum value\n * @property {Constructor<StepValidator>} step - Validator for step value\n * @property {Constructor<MinLengthValidator>} minlength - Validator for minimum length\n * @property {Constructor<MaxLengthValidator>} maxlength - Validator for maximum length\n * @property {Constructor<PatternValidator>} pattern - Validator for regex pattern\n * @property {Constructor<EqualsValidator>} equals - Validator for equality\n * @property {Constructor<DiffValidator>} diff - Validator for difference\n * @property {Constructor<LessThanValidator>} lessthan - Validator for less than comparison\n * @property {Constructor<LessThanOrEqualValidator>} lessthanorequal - Validator for less than or equal comparison\n * @property {Constructor<GreaterThanValidator>} greaterthan - Validator for greater than comparison\n * @property {Constructor<GreaterThanOrEqualValidator>} greaterthanorequal - Validator for greater than or equal comparison\n *\n * @const ValidatableByAttribute\n * @type {ValidatableByAttributeMap}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const ValidatableByAttribute: Record<string, Constructor<Validator>> = {\n  [UIKeys.REQUIRED]: RequiredValidator,\n  [UIKeys.MIN]: MinValidator,\n  [UIKeys.MAX]: MaxValidator,\n  [UIKeys.STEP]: StepValidator,\n  [UIKeys.MIN_LENGTH]: MinLengthValidator,\n  [UIKeys.MAX_LENGTH]: MaxLengthValidator,\n  [UIKeys.PATTERN]: PatternValidator,\n  [UIKeys.EQUALS]: EqualsValidator,\n  [UIKeys.DIFF]: DiffValidator,\n  [UIKeys.LESS_THAN]: LessThanValidator,\n  [UIKeys.LESS_THAN_OR_EQUAL]: LessThanOrEqualValidator,\n  [UIKeys.GREATER_THAN]: GreaterThanValidator,\n  [UIKeys.GREATER_THAN_OR_EQUAL]: GreaterThanOrEqualValidator,\n};\n\n/**\n * @description Standard date format string for HTML5 date inputs\n * @summary Format string for HTML5 date inputs (yyyy-MM-dd)\n * This constant defines the standard date format string used for HTML5 date inputs.\n *\n * @const HTML5DateFormat\n * @type {string}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const HTML5DateFormat = \"yyyy-MM-dd\";\n\n/**\n * @description Collection of HTML5 input type values\n * @summary Maps input type constants to their HTML attribute values\n * This constant provides a mapping of input type constants to their corresponding\n * HTML attribute values for use in form elements.\n *\n * @typedef {Object} HTML5InputTypesMap\n * @property {string} BUTTON - Button input type\n * @property {string} CHECKBOX - Checkbox input type\n * @property {string} COLOR - Color picker input type\n * @property {string} DATE - Date picker input type\n * @property {string} DATETIME_LOCAL - Local datetime picker input type\n * @property {string} EMAIL - Email input type with validation\n * @property {string} FILE - File upload input type\n * @property {string} HIDDEN - Hidden input type\n * @property {string} IMAGE - Image input type\n * @property {string} MONTH - Month picker input type\n * @property {string} NUMBER - Numeric input type\n * @property {string} PASSWORD - Password input type with masked text\n * @property {string} RADIO - Radio button input type\n * @property {string} RANGE - Range slider input type\n * @property {string} RESET - Form reset button input type\n * @property {string} SEARCH - Search input type\n * @property {string} SUBMIT - Form submit button input type\n * @property {string} TEL - Telephone number input type\n * @property {string} TEXT - Basic text input type\n * @property {string} TIME - Time picker input type\n * @property {string} URL - URL input type with validation\n * @property {string} WEEK - Week picker input type\n *\n * @const HTML5InputTypes\n * @type {HTML5InputTypesMap}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const HTML5InputTypes = {\n  BUTTON: \"button\",\n  CHECKBOX: \"checkbox\",\n  COLOR: \"color\",\n  DATE: UIKeys.DATE,\n  DATETIME_LOCAL: \"datetime-local\",\n  EMAIL: UIKeys.EMAIL,\n  FILE: \"file\",\n  HIDDEN: \"hidden\",\n  IMAGE: \"image\",\n  MONTH: \"month\",\n  NUMBER: \"number\",\n  PASSWORD: UIKeys.PASSWORD,\n  RADIO: \"radio\",\n  RANGE: \"range\",\n  RESET: \"reset\",\n  SEARCH: \"search\",\n  SUBMIT: \"submit\",\n  TEL: \"tel\",\n  TEXT: \"text\",\n  TIME: \"time\",\n  URL: UIKeys.URL,\n  WEEK: \"week\",\n};\n\n/**\n * @description Array of HTML5 input types that use checkboxes\n * @summary List of input types that represent checkable controls\n * This constant defines an array of HTML5 input types that represent\n * checkable controls (checkbox and radio).\n *\n * @const HTML5CheckTypes\n * @type {string[]}\n * @readonly\n * @memberOf module:ui-decorators\n */\nexport const HTML5CheckTypes = [\n  HTML5InputTypes.CHECKBOX,\n  HTML5InputTypes.RADIO,\n];\n"]}

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

@@ -1,47 +1,255 @@
 import "reflect-metadata";
 import { CrudOperationKeys } from "./types";
 /**
- * @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 declare function hideOn(...operations: CrudOperationKeys[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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 declare function hidden(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
 /**
- * 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 declare function uielement(tag: string, props?: Record<string, any>, serialize?: boolean): (original: any, propertyKey?: any) => void;
 /**
- * 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 declare function uiprop(propName?: string | undefined, stringify?: boolean): (target: any, propertyKey: string) => void;
 /**
- * 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 declare function uichild(propName?: string | undefined, stringify?: boolean, tag?: string): (target: any, propertyKey: string) => void;
+/**
+ * @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 declare function uilistprop(propName?: string | undefined, props?: Record<string, any>): (target: any, propertyKey: string) => void;