@decaf-ts/ui-decorators 0.20.4 → 0.20.7

package/dist/ui-decorators.cjs

@@ -1,2 +1,1059 @@
-var e,t;e=this,t=function(e,t,r,a,o){"use strict";var s;e.UIMediaBreakPoints=void 0,(s=e.UIMediaBreakPoints||(e.UIMediaBreakPoints={})).SMALL="small",s.MEDIUM="medium",s.LARGE="large",s.XLARGE="xlarge";const n={REFLECT:"ui",UIMODEL:"uimodel",RENDERED_BY:"rendered-by",ELEMENT:"uielement",PROP:"uiprop",CHILD:"uichild",NAME:"name",NAME_PREFIX:"input-",VALIDATION_MESSAGE:"validationMessage",UILISTMODEL:"uilistmodel",UILISTPROP:"uilistprop",UILAYOUT:"uilayout",UILAYOUTPROP:"uilayoutprop",HANDLERS:"handlers",TYPE:"type",SUB_TYPE:"subType",HIDDEN:"hidden",HIDE_FOR:"hide-for",SHOW_FOR:"show-for",RENDER_IF:"render-if",FORMAT:"format",ORDER:"order",PAGE:"page",EVENTS:"events",FIRST:"first",LAST:"last",READ_ONLY:"readonly",SEQUENCE:"sequence",REQUIRED:t.ValidationKeys.REQUIRED,MIN:t.ValidationKeys.MIN,MIN_LENGTH:t.ValidationKeys.MIN_LENGTH,MAX:t.ValidationKeys.MAX,MAX_LENGTH:t.ValidationKeys.MAX_LENGTH,PATTERN:t.ValidationKeys.PATTERN,URL:t.ValidationKeys.URL,STEP:t.ValidationKeys.STEP,DATE:t.ValidationKeys.DATE,EMAIL:t.ValidationKeys.EMAIL,PASSWORD:t.ValidationKeys.PASSWORD,EQUALS:t.ValidationKeys.EQUALS,DIFF:t.ValidationKeys.DIFF,LESS_THAN:t.ValidationKeys.LESS_THAN,LESS_THAN_OR_EQUAL:t.ValidationKeys.LESS_THAN_OR_EQUAL,GREATER_THAN:t.ValidationKeys.GREATER_THAN,GREATER_THAN_OR_EQUAL:t.ValidationKeys.GREATER_THAN_OR_EQUAL},i={[n.EMAIL]:t.EmailValidator,[n.URL]:t.URLValidator,[n.DATE]:t.DateValidator,[n.PASSWORD]:t.PasswordValidator},d={[n.REQUIRED]:t.RequiredValidator,[n.MIN]:t.MinValidator,[n.MAX]:t.MaxValidator,[n.STEP]:t.StepValidator,[n.MIN_LENGTH]:t.MinLengthValidator,[n.MAX_LENGTH]:t.MaxLengthValidator,[n.PATTERN]:t.PatternValidator,[n.EQUALS]:t.EqualsValidator,[n.DIFF]:t.DiffValidator,[n.LESS_THAN]:t.LessThanValidator,[n.LESS_THAN_OR_EQUAL]:t.LessThanOrEqualValidator,[n.GREATER_THAN]:t.GreaterThanValidator,[n.GREATER_THAN_OR_EQUAL]:t.GreaterThanOrEqualValidator},l="yyyy-MM-dd",c={BUTTON:"button",CHECKBOX:"checkbox",COLOR:"color",DATE:n.DATE,DATETIME_LOCAL:"datetime-local",EMAIL:n.EMAIL,FILE:"file",HIDDEN:"hidden",IMAGE:"image",MONTH:"month",NUMBER:"number",PASSWORD:n.PASSWORD,RADIO:"radio",RANGE:"range",RESET:"reset",SEARCH:"search",SUBMIT:"submit",TEL:"tel",TEXT:"text",TEXTAREA:"textarea",SELECT:"select",TIME:"time",URL:n.URL,WEEK:"week"},p=[c.CHECKBOX,c.RADIO],E={cancel:"cancel",confirm:"confirm",submit:"submit",clear:"clear",back:"back",[r.OperationKeys.CREATE]:r.OperationKeys.CREATE,[r.OperationKeys.READ]:r.OperationKeys.READ,[r.OperationKeys.UPDATE]:r.OperationKeys.UPDATE,[r.OperationKeys.DELETE]:r.OperationKeys.DELETE};class u extends r.InternalError{constructor(e){super(e,u.name)}}const f=e=>"function"==typeof e&&/^class\s/.test(e+"");function h(e,t){return a.Metadata.key(n.REFLECT,a.DecorationKeys.PROPERTIES,e,t)}function y(e,r,...a){if(e===n.DATE){if(!r)return"";const e=a.shift()||l;return t.formatDate(new Date(r),e)}return r}function M(e){if("number"==typeof e&&!isNaN(e))return e;const t=Number(e);return isNaN(t)?void 0:t}function R(e){if(!e)return e;const t={"&":"&amp;","<":"&lt;",">":"&gt;"};return(""+e).replace(/[&<>]/g,e=>t[e]||e)}function T(e){let r=Date.now();try{t.Model.pk(e.constructor)&&(r=e[t.Model.pk(e.constructor)])}catch(e){}return`${e.constructor.name}-${r}`}class m{static{this.cache={}}constructor(e){this.flavour=e,this.initialized=!1,m.register(this)}translate(e,r=!0){if(r)switch(e){case t.ReservedModels.STRING.name.toLowerCase():return c.TEXT;case t.ReservedModels.NUMBER.name.toLowerCase():case t.ReservedModels.BIGINT.name.toLowerCase():return c.NUMBER;case t.ReservedModels.BOOLEAN.name.toLowerCase():return c.CHECKBOX;case t.ReservedModels.DATE.name.toLowerCase():return c.DATE}else switch(e){case c.SELECT:case c.TEXT:case c.EMAIL:case c.COLOR:case c.PASSWORD:case c.TEL:case c.URL:case c.SEARCH:case c.HIDDEN:case c.TEXTAREA:case c.RADIO:return t.ReservedModels.STRING.name.toLowerCase();case c.NUMBER:return t.ReservedModels.NUMBER.name.toLowerCase();case c.CHECKBOX:return t.ReservedModels.BOOLEAN.name.toLowerCase();case c.DATE:case c.DATETIME_LOCAL:case c.TIME:return t.ReservedModels.DATE.name.toLowerCase()}return e}getClassDecoratorsMetadata(e){return[t.Model.uiModelOf(e.constructor),t.Model.uiListModelOf(e.constructor),t.Model.uiHandlersFor(e.constructor),t.Model.uiLayoutOf(e.constructor)].filter(Boolean)}sortChildrenByOrder(e=[]){return e.sort((r,a)=>{const o=r.props?.order??0,s=a.props?.order??0,i=r=>r===n.FIRST?0:typeof r===t.Primitives.NUMBER?1:r===n.LAST?e.length+e.indexOf(a):1,d=i(o),l=i(s);return d!==l?d-l:1===d&&typeof o===t.Primitives.NUMBER&&typeof s===t.Primitives.NUMBER?o-s:0})}isCustomValidator(e){return!Object.values(t.ValidationKeys).includes(e)&&!Object.values(n).includes(e)}isValidatableByType(e){return Object.keys(i).includes(e)}isValidatableByAttribute(e){return Object.keys(d).includes(e)}toAttributeValue(e,t){if(!Object.keys(d).includes(e))throw Error(`Invalid attribute key "${e}". Expected one of: ${Object.keys(d).join(", ")}.`);return e===n.REQUIRED||t[e]}toFieldDefinition(e,o={},s=!0){const{inheritProps:i,...d}=o;o=d;const p=this.getClassDecoratorsMetadata(e);if(!p.length)throw new u(`No ui definitions set for model ${e.constructor.name}. Did you use @uimodel?`);const E=Object.assign({},...p,i||{}),{tag:f,props:h,item:M,handlers:R}=E,m=t.Model.uiPropertiesOf(e.constructor);let O,g=M?.props||{},L={};const A=(e,t)=>e?[e,t].join("."):t;if(m){const s=a.Metadata.get(e.constructor,t.ValidationKeys.REFLECT)||{};for(const i of m){const d=t.Model.uiDecorationOf(e.constructor,i);let p;try{p=t.Model.uiTypeOf(e.constructor,i)}catch(e){if(!(e instanceof r.NotFoundError))throw e}if(t.Model.uiIsHidden(e.constructor,i)&&!t.Model.uiElementOf(e.constructor,i))throw new u(`@uielement no found in "${i}". It is required to use hiddenOn decorator.`);Object.entries(d).map(([e,t])=>({key:e,props:t})).sort(e=>[n.ELEMENT,n.CHILD].includes(e.key)?-1:1).forEach(r=>{if(!r)throw new u("No decorator found");switch(r.key){case n.PROP:g[i]=r.props;break;case n.CHILD:{const a=r.props?.props?.name||i;try{if(!t.Model.isModel(t.Model.build({},a))&&!t.Model.isPropertyModel(e,a))throw new u(`Child "${a}" must be a model.`)}catch(e){throw new u(`Child "${a}" must be a model.`)}let s;const n=e[i];if("object"!=typeof n||null===n||Array.isArray(n)){const e=r.props.props?.name;s=new(t.Model.get(e))}O=O||[];const d=Object.assign({},o||{},{model:s},{inheritProps:r.props,childOf:A(o?.childOf,i)}),l=this.toFieldDefinition(n||s,d,!1),{inheritProps:c}=d;c&&(l.props=Object.assign({},l.props,c.props||{})),O.push(l);break}case n.UILISTPROP:{L=L||{};const e=r.props;e.name&&(L[e.name]="object"==typeof e?.props&&n.SEQUENCE in e.props?e.props:i);const t=Object.assign({},E.props?.item||{},M?.props||{},e?.props||{},o);g={tag:M?.tag||t.render||"",props:Object.assign({},g?.props,{mapper:L},t)};break}case n.EVENTS:case n.HIDDEN:case n.HIDE_FOR:case n.SHOW_FOR:case n.PAGE:case n.ORDER:case n.UILAYOUTPROP:case n.ELEMENT:{O=O||[];const t=r.props,d=r.key===n.HIDE_FOR?{hideFor:r.props}:r.key===n.SHOW_FOR?{showFor:r.props}:{},p=Object.assign({},g?.props,t.props||{},d,t?.props?.name?{path:A(o?.childOf,t.props.name),childOf:void 0}:{},o,{name:t.props?.name||i});if(r.key===n.ELEMENT){const r={tag:t.tag||g?.tag||f||"",props:p},o=s[i];if(o)for(const e of Object.entries(o).map(([e,t])=>({key:e,props:t})))this.isValidatableByAttribute(e.key)?r.props[this.translate(e.key)]=this.toAttributeValue(e.key,e.props):this.isValidatableByType(e.key)?(e.key===c.DATE&&(r.props[n.FORMAT]=e.props.format||l),r.props[n.TYPE]=e.key):this.isCustomValidator(e.key)&&(p[n.SUB_TYPE]=e.key,e.props?.message&&(p[n.VALIDATION_MESSAGE]=e.props.message));if(!r.props[n.TYPE]){const t=a.Metadata.type(e.constructor,i).name;r.props[n.TYPE]=this.translate(t.toLowerCase(),!0)}r.props.value=y(r.props[n.TYPE],e[i],r.props[n.FORMAT]),O.push(r)}else{const e=O.find(e=>e.props?.name===i||[n.UILAYOUTPROP,n.PAGE,n.EVENTS].includes(r.key)&&(e.props?.childOf===i||e.props?.childOf?.endsWith("."+i)));if(e)if(r.key===n.HIDE_FOR||r.key===n.SHOW_FOR)e.props=Object.assign({},e.props,d);else if(r.key!==n.UILAYOUTPROP)e.props=Object.assign({},e.props,{[r.key]:t});else{const{row:t,col:a,props:o}=r.props;e.props=Object.assign({},o||{},e.props,t,a)}}break}default:throw new u("Invalid key: "+r.key)}})}}o=Object.assign({},h,o,{handlers:R||{}});const D=new Set([...Array.isArray(o?.namespaces)?o.namespaces:[],..."string"==typeof o?.namespace?[o.namespace]:[]].filter(Boolean)),I=o?.operation;O=this.sortChildrenByOrder(O).filter(e=>{const t=e?.props?.hidden||[];if(t.length>0&&t.includes(I))return!1;const r=e?.props?.hideFor||[],a=e?.props?.showFor||[];return!(r.length>0&&[...D].some(e=>r.includes(e))||a.length>0&&![...D].some(e=>a.includes(e)))});const N={tag:f,item:g,props:o,children:O?.length?O:void 0};return s&&(N.rendererId=T(e)),N}static register(e){if(e.flavour in this.cache)throw new r.InternalError(`Rendering engine under ${e.flavour} already exists`);this.cache[e.flavour]=e,this.current=e}static getOrBoot(e){if(e instanceof m)return e;const t=new e;return t.initialize(),t}static get(e){if(!e)return this.getOrBoot(this.current);if(!(e in this.cache))throw new r.InternalError(`Rendering engine under ${e} does not exist`);return this.getOrBoot(this.cache[e])}static render(e,...a){if(!t.Model.get(e.constructor.name)&&!t.Model.fromObject(e))throw new r.InternalError("No model registered found");const o=t.Model.renderedBy(e.constructor);return m.get(o).render(e,...a)}}function O(...e){return(t,r)=>a.propMetadata(h(r,n.HIDDEN),e)(t,r)}function g(...e){return(t,r)=>a.propMetadata(h(r,n.SHOW_FOR),e)(t,r)}function L(e,t){return(r,o)=>{a.propMetadata(h(o,n.EVENTS),{..."object"==typeof e?e:{[e]:t}})(r,o)}}class A extends t.Validator{getMessage(e,...t){return A.translateService?A.translateService.translate(e,...t):super.getMessage(e,...t)}}class D extends o.LoggedClass{constructor(){super(),this.enableDarkMode=!0,this.isDarkMode=!1,this.item={tag:""},this.props={},this.route="",this.borders=!1,this.OperationKeys=r.OperationKeys,this.initialized=!1,this.events={},this.handlers={}}get repository(){return this._repository}set repository(e){this._repository=e}async render(...e){this.log.for(this.render).info(`render for ${this.componentName} with ${JSON.stringify(e)}`)}async refresh(...e){this.log.for(this.refresh).info("Refresh called with args: "+e)}async initialize(...e){this.initialized=!0}async translate(...e){this.log.for(this.translate).info(`translate for ${this.componentName} with ${JSON.stringify(e)}`)}async preview(...e){this.log.for(this.preview).debug("Preview called with args: "+e)}async submit(...e){this.log.for(this.submit).info(`submit for ${this.componentName} with ${JSON.stringify(e)}`)}parseHandlers(e,t){const r={};return Object.entries(e).forEach(([e,a])=>{if(f(a)){const o=new a,s=e in o?o[e]:o.handle;r[e]=s,t.handlers[e]=s}else r[e]=a,t.handlers[e]=a}),r}parseEvents(e,t){const r={};return Object.entries(e).forEach(([e,a])=>{const o=e,s=a();if(f(s)){const a=(new s)[e];a&&(r[o]=a,t.events[o]=a)}else r[o]=a,t.events[o]=a}),r}}class I extends o.LoggedClass{translate(e,t){this.log.for(this.translate).info(`Must translate ${e} with params ${JSON.stringify(t||{})}`)}instant(e,t){this.log.for(this.instant).info(`Must translate ${e} with params ${JSON.stringify(t||{})}`)}}function N(e,t){return(r,o)=>{const s={tag:e||r.name,props:t};return a.metadata(a.Metadata.key(n.REFLECT,n.UIMODEL),s)(r)}}function b(e){return a.apply(a.metadata(a.Metadata.key(n.REFLECT,n.RENDERED_BY),e))}function C(e,t){return(r,o)=>{const s={item:{tag:e||r.name,props:t}};return a.metadata(a.Metadata.key(n.REFLECT,n.UILISTMODEL),s)(r)}}function S(e){return t=>{const r={handlers:e};return a.metadata(a.Metadata.key(n.REFLECT,n.HANDLERS),r)(t)}}function P(t,r=1,o=1,s={}){const i=Object.assign({..."boolean"==typeof r?{flexMode:r,cols:1}:{flexMode:!1,cols:r},rows:o,...Object.assign({breakpoint:e.UIMediaBreakPoints.LARGE},s)});return(e,r)=>(a.metadata(a.Metadata.key(n.REFLECT,n.UILAYOUT),i)(e),N(t,i)(e,r))}function k(e,t=1,r=!1,a={}){let o=[];return"object"==typeof t&&(o=t,t=o.length),N(e,{pages:t,paginated:r,pageTitles:o,props:a})}t.Model.prototype.render=function(...e){return m.render(this,...e)},t.Model.renderedBy=(e=>a.Metadata.get(e,a.Metadata.key(n.REFLECT,n.RENDERED_BY))).bind(t.Model),t.Model.uiPropertiesOf=(e=>{const t=a.Metadata.get(e,a.Metadata.key(n.REFLECT,a.DecorationKeys.PROPERTIES));if(t)return Object.keys(t)}).bind(t.Model),t.Model.uiDecorationOf=(e,t,r)=>{const o=a.Metadata.get(e,a.Metadata.key(n.REFLECT,a.DecorationKeys.PROPERTIES,t));if(o)return r?o[r]:o},t.Model.uiModelOf=e=>a.Metadata.get(e,a.Metadata.key(n.REFLECT,n.UIMODEL)),t.Model.uiElementOf=(e,t)=>a.Metadata.get(e,h(t,n.ELEMENT)),t.Model.uiListModelOf=e=>a.Metadata.get(e,a.Metadata.key(n.REFLECT,n.UILISTMODEL)),t.Model.uiHandlersFor=e=>a.Metadata.get(e,a.Metadata.key(n.REFLECT,n.HANDLERS)),t.Model.uiLayoutOf=e=>a.Metadata.get(e,a.Metadata.key(n.REFLECT,n.UILAYOUT)),t.Model.uiIsHidden=(e,t)=>!!a.Metadata.get(e,h(t,n.HIDDEN)),t.Model.uiIsHiddenOn=(e,t,r)=>{const o=a.Metadata.get(e,h(t,n.HIDDEN));return!!o&&(r?o.includes(r):o)},t.Model.uiTypeOf=(e,t)=>{const o=a.Metadata.get(e,a.Metadata.key(n.REFLECT,a.DecorationKeys.PROPERTIES,t));if(!o)throw new r.NotFoundError(`No metadata found for property '${t}' on model '${e.name}'`);const s=Object.keys(o).filter(e=>[n.PROP,n.ELEMENT,n.CHILD].includes(e));if(0===s.length)throw new r.NotFoundError(`No UI type metadata found for property '${t}' on model '${e.name}'`);if(s.length>1)throw new u("Only one type of decoration is allowed. Please choose between @uiprop, @uichild or @uielement");return o[s[0]]},t.Model.uiListItems=(e=>{const t=a.Metadata.get(e,a.Metadata.key(n.REFLECT,a.DecorationKeys.PROPERTIES));if(t)return Object.keys(t)}).bind(t.Model);const U=t.ModelBuilder.prototype;U.decorateClass||(U.decorateClass=function(e){return this._classDecorators||(this._classDecorators=[]),this._classDecorators.push(e),this}),U.uimodel=function(e,t){return this.decorateClass(N(e,t))},U.renderedBy=function(e){return this.decorateClass(b(e))},U.uilistmodel=function(e,t){return this.decorateClass(C(e,t))},U.uihandlers=function(e){return this.decorateClass(S(e))},U.uilayout=function(e,t,r,a){return this.decorateClass(P(e,t,r,a))},U.uisteppedmodel=function(e,t,r,a){return this.decorateClass(k(e,t,r,a))};const w="##VERSION##",v="##PACKAGE##";a.Metadata.registerLibrary(v,w),e.ActionRoles=E,e.COMMIT="b1ab2bc",e.ComponentEventNames={Render:"render",BackButtonClickEvent:"backButtonNavigationEndEvent",Refresh:"RefreshEvent",Click:"ClickEvent",Change:"ChangeEvent",Submit:"SubmitEvent",ValidationError:"validationErrorEvent",ThemeChange:"themeChangeEvent",FormGroupLoaded:"formGroupLoadedEvent"},e.DecafComponent=D,e.DecafEventHandler=class extends D{constructor(){super()}handle(...e){this.log.for(this.handle).info(`component ${this.componentName} handling ${JSON.stringify(e)}`)}handleClick(...e){this.log.for(this.handleClick).info(`component ${this.componentName} handling click ${JSON.stringify(e)}`)}handleAction(...e){this.log.for(this.handleAction).info(`component ${this.componentName} handling action ${JSON.stringify(e)}`)}},e.DecafTranslateService=I,e.ElementPositions={left:"left",center:"center",right:"right",top:"top",bottom:"bottom"},e.ElementSizes={xsmall:"xsmall",small:"small",medium:"medium",default:"default",large:"large",xLarge:"xlarge","2xLarge":"2xlarge",auto:"auto",expand:"expand",block:"block",half:"half",full:"full"},e.FULL_VERSION="0.20.4-b1ab2bc",e.HTML5CheckTypes=p,e.HTML5DateFormat=l,e.HTML5InputTypes=c,e.LayoutGridGaps={small:"small",medium:"medium",large:"large",collapse:"collapse",none:""},e.PACKAGE_NAME=v,e.RenderingEngine=m,e.RenderingError=u,e.TransactionHooks={BeforeRead:"beforeRead",AfterRead:"afterRead",BeforeCreate:"beforeCreate",AfterCreate:"afterCreate",BeforeUpdate:"beforeUpdate",AfterUpdate:"afterUpdate",BeforeDelete:"beforeDelete",AfterDelete:"afterDelete"},e.UIKeys=n,e.UIValidator=A,e.VERSION=w,e.ValidatableByAttribute=d,e.ValidatableByType=i,e.WindowColorSchemes={light:"light",dark:"dark",undefined:"undefined"},e.escapeHtml=R,e.formatByType=y,e.generateUIModelID=T,e.getUIAttributeKey=h,e.hidden=()=>O(r.OperationKeys.CREATE,r.OperationKeys.READ,r.OperationKeys.UPDATE,r.OperationKeys.DELETE),e.hideFor=(...e)=>(t,r)=>a.propMetadata(h(r,n.HIDE_FOR),e)(t,r),e.hideOn=O,e.isClassConstructor=f,e.parseToNumber=M,e.parseValueByType=function e(a,o,s){let n;switch(a){case Array.name:n=(Array.isArray(o)?o.map(r=>e(t.ReservedModels.STRING.name.toLowerCase(),r,s)):[o]).join(",");break;case c.NUMBER:n=M(o);break;case c.DATE:{const e=s.format;o&&(""+o).trim().length&&(n=typeof o===t.ReservedModels.NUMBER.name.toLowerCase()?new Date(o):o?e?t.parseDate(e,o):new Date(o):void 0);break}default:n=typeof o===t.ReservedModels.OBJECT.name.toLowerCase()?Array.isArray(o)?o.join(","):JSON.stringify(o):typeof o===t.ReservedModels.BOOLEAN.name.toLowerCase()?o:typeof o===t.ReservedModels.STRING.name.toLowerCase()?R(o):n}if(void 0===n)throw new r.InternalError(`Failed to parse value of type ${a} from ${typeof o} - ${o}`);return n},e.renderIf=(...e)=>g(...e),e.renderedBy=b,e.revertHtml=e=>{const t={"&amp;":"&","&lt;":"<","&gt;":">"};return(""+e).replace(/&lt;|&gt;|&amp;/g,e=>t[e]||e)},e.showFor=g,e.uichild=(e,t,r={},o=!1,s=!1)=>(i,d)=>{const l={tag:t,serialize:s,props:Object.assign({},r||{},{name:e||d},o?{customTypes:[Array.name],multiple:!0}:{multiple:r?.multiple||!1})};a.propMetadata(h(d,n.CHILD),l)(i,d)},e.uielement=(e,t,r=!1)=>(o,s)=>{"object"==typeof e&&(t=e,e="");const i={tag:e,serialize:r,props:Object.assign({},t||{},{name:s})};return a.propMetadata(h(s,n.ELEMENT),i)(o,s)},e.uihandlers=S,e.uilayout=P,e.uilayoutprop=(e=1,t=1)=>(r,o)=>{const s={name:o,props:Object.assign({},{row:t,col:e})};a.propMetadata(h(o,n.UILAYOUTPROP),s)(r,o)},e.uilistmodel=C,e.uilistprop=(e=void 0,t)=>(r,o)=>{const s={name:e||o,props:t||{}};a.propMetadata(h(o,n.UILISTPROP),s)(r,o)},e.uimodel=N,e.uion=L,e.uionclick=e=>L("handleClick",e),e.uionrender=e=>L("render",e),e.uiorder=(e=n.FIRST)=>(t,r)=>a.propMetadata(h(r,n.ORDER),e)(t,r),e.uipageprop=(e=1)=>(t,r)=>a.propMetadata(h(r,n.PAGE),e)(t,r),e.uiprop=(e=void 0,t=!1)=>(r,o)=>{const s={name:e||o,stringify:t};a.propMetadata(h(o,n.PROP),s)(r,o)},e.uisteppedmodel=k,e.uitablecol=(e=n.LAST,t)=>(r,o)=>{const s={name:o,props:{sequence:e,...t?{valueParserFn:t}:{}}};a.propMetadata(h(o,n.UILISTPROP),s)(r,o)}},"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@decaf-ts/decorator-validation"),require("@decaf-ts/db-decorators"),require("@decaf-ts/decoration"),require("@decaf-ts/logging")):"function"==typeof define&&define.amd?define(["exports","@decaf-ts/decorator-validation","@decaf-ts/db-decorators","@decaf-ts/decoration","@decaf-ts/logging"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self)["ui-decorators"]={},e.decafTsDecoratorValidation,e.decafTsDbDecorators,e.decafTsDecoration,e.decafTsLogging);
-//# sourceMappingURL=ui-decorators.cjs.map
+(function(global, factory) {
+    typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@decaf-ts/decorator-validation"), require("@decaf-ts/db-decorators"), require("@decaf-ts/decoration"), require("@decaf-ts/logging")) : typeof define === "function" && define.amd ? define([ "exports", "@decaf-ts/decorator-validation", "@decaf-ts/db-decorators", "@decaf-ts/decoration", "@decaf-ts/logging" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+    factory(global["ui-decorators"] = {}, global.decafTsDecoratorValidation, global.decafTsDbDecorators, global.decafTsDecoration, global.decafTsLogging));
+})(this, function(exports, decoratorValidation, dbDecorators, decoration, logging) {
+    "use strict";
+    exports.UIMediaBreakPoints = void 0;
+    (function(UIMediaBreakPoints) {
+        UIMediaBreakPoints["SMALL"] = "small";
+        UIMediaBreakPoints["MEDIUM"] = "medium";
+        UIMediaBreakPoints["LARGE"] = "large";
+        UIMediaBreakPoints["XLARGE"] = "xlarge";
+    })(exports.UIMediaBreakPoints || (exports.UIMediaBreakPoints = {}));
+    const UIKeys = {
+        REFLECT: `ui`,
+        UIMODEL: "uimodel",
+        RENDERED_BY: "rendered-by",
+        ELEMENT: "uielement",
+        PROP: "uiprop",
+        CHILD: "uichild",
+        NAME: "name",
+        NAME_PREFIX: "input-",
+        VALIDATION_MESSAGE: "validationMessage",
+        UILISTMODEL: "uilistmodel",
+        UILISTPROP: "uilistprop",
+        UILAYOUT: "uilayout",
+        UILAYOUTPROP: "uilayoutprop",
+        HANDLERS: "handlers",
+        TYPE: "type",
+        SUB_TYPE: "subType",
+        HIDDEN: "hidden",
+        HIDE_FOR: "hide-for",
+        SHOW_FOR: "show-for",
+        RENDER_IF: "render-if",
+        FORMAT: "format",
+        ORDER: "order",
+        PAGE: "page",
+        EVENTS: "events",
+        FIRST: "first",
+        LAST: "last",
+        READ_ONLY: "readonly",
+        SEQUENCE: "sequence",
+        REQUIRED: decoratorValidation.ValidationKeys.REQUIRED,
+        MIN: decoratorValidation.ValidationKeys.MIN,
+        MIN_LENGTH: decoratorValidation.ValidationKeys.MIN_LENGTH,
+        MAX: decoratorValidation.ValidationKeys.MAX,
+        MAX_LENGTH: decoratorValidation.ValidationKeys.MAX_LENGTH,
+        PATTERN: decoratorValidation.ValidationKeys.PATTERN,
+        URL: decoratorValidation.ValidationKeys.URL,
+        STEP: decoratorValidation.ValidationKeys.STEP,
+        DATE: decoratorValidation.ValidationKeys.DATE,
+        EMAIL: decoratorValidation.ValidationKeys.EMAIL,
+        PASSWORD: decoratorValidation.ValidationKeys.PASSWORD,
+        EQUALS: decoratorValidation.ValidationKeys.EQUALS,
+        DIFF: decoratorValidation.ValidationKeys.DIFF,
+        LESS_THAN: decoratorValidation.ValidationKeys.LESS_THAN,
+        LESS_THAN_OR_EQUAL: decoratorValidation.ValidationKeys.LESS_THAN_OR_EQUAL,
+        GREATER_THAN: decoratorValidation.ValidationKeys.GREATER_THAN,
+        GREATER_THAN_OR_EQUAL: decoratorValidation.ValidationKeys.GREATER_THAN_OR_EQUAL
+    };
+    const ValidatableByType = {
+        [UIKeys.EMAIL]: decoratorValidation.EmailValidator,
+        [UIKeys.URL]: decoratorValidation.URLValidator,
+        [UIKeys.DATE]: decoratorValidation.DateValidator,
+        [UIKeys.PASSWORD]: decoratorValidation.PasswordValidator
+    };
+    const ValidatableByAttribute = {
+        [UIKeys.REQUIRED]: decoratorValidation.RequiredValidator,
+        [UIKeys.MIN]: decoratorValidation.MinValidator,
+        [UIKeys.MAX]: decoratorValidation.MaxValidator,
+        [UIKeys.STEP]: decoratorValidation.StepValidator,
+        [UIKeys.MIN_LENGTH]: decoratorValidation.MinLengthValidator,
+        [UIKeys.MAX_LENGTH]: decoratorValidation.MaxLengthValidator,
+        [UIKeys.PATTERN]: decoratorValidation.PatternValidator,
+        [UIKeys.EQUALS]: decoratorValidation.EqualsValidator,
+        [UIKeys.DIFF]: decoratorValidation.DiffValidator,
+        [UIKeys.LESS_THAN]: decoratorValidation.LessThanValidator,
+        [UIKeys.LESS_THAN_OR_EQUAL]: decoratorValidation.LessThanOrEqualValidator,
+        [UIKeys.GREATER_THAN]: decoratorValidation.GreaterThanValidator,
+        [UIKeys.GREATER_THAN_OR_EQUAL]: decoratorValidation.GreaterThanOrEqualValidator
+    };
+    const HTML5DateFormat = "yyyy-MM-dd";
+    const HTML5InputTypes = {
+        BUTTON: "button",
+        CHECKBOX: "checkbox",
+        COLOR: "color",
+        DATE: UIKeys.DATE,
+        DATETIME_LOCAL: "datetime-local",
+        EMAIL: UIKeys.EMAIL,
+        FILE: "file",
+        HIDDEN: "hidden",
+        IMAGE: "image",
+        MONTH: "month",
+        NUMBER: "number",
+        PASSWORD: UIKeys.PASSWORD,
+        RADIO: "radio",
+        RANGE: "range",
+        RESET: "reset",
+        SEARCH: "search",
+        SUBMIT: "submit",
+        TEL: "tel",
+        TEXT: "text",
+        TEXTAREA: "textarea",
+        SELECT: "select",
+        TIME: "time",
+        URL: UIKeys.URL,
+        WEEK: "week"
+    };
+    const HTML5CheckTypes = [ HTML5InputTypes.CHECKBOX, HTML5InputTypes.RADIO ];
+    const ComponentEventNames = {
+        Render: "render",
+        BackButtonClickEvent: "backButtonNavigationEndEvent",
+        Refresh: "RefreshEvent",
+        Click: "ClickEvent",
+        Change: "ChangeEvent",
+        Submit: "SubmitEvent",
+        ValidationError: "validationErrorEvent",
+        ThemeChange: "themeChangeEvent",
+        FormGroupLoaded: "formGroupLoadedEvent"
+    };
+    const TransactionHooks = {
+        BeforeRead: "beforeRead",
+        AfterRead: "afterRead",
+        BeforeCreate: "beforeCreate",
+        AfterCreate: "afterCreate",
+        BeforeUpdate: "beforeUpdate",
+        AfterUpdate: "afterUpdate",
+        BeforeDelete: "beforeDelete",
+        AfterDelete: "afterDelete"
+    };
+    const ElementSizes = {
+        xsmall: "xsmall",
+        small: "small",
+        medium: "medium",
+        default: "default",
+        large: "large",
+        xLarge: "xlarge",
+        "2xLarge": "2xlarge",
+        auto: "auto",
+        expand: "expand",
+        block: "block",
+        half: "half",
+        full: "full"
+    };
+    const ElementPositions = {
+        left: "left",
+        center: "center",
+        right: "right",
+        top: "top",
+        bottom: "bottom"
+    };
+    const LayoutGridGaps = {
+        small: "small",
+        medium: "medium",
+        large: "large",
+        collapse: "collapse",
+        none: ""
+    };
+    const ActionRoles = {
+        cancel: "cancel",
+        confirm: "confirm",
+        submit: "submit",
+        clear: "clear",
+        back: "back",
+        [dbDecorators.OperationKeys.CREATE]: dbDecorators.OperationKeys.CREATE,
+        [dbDecorators.OperationKeys.READ]: dbDecorators.OperationKeys.READ,
+        [dbDecorators.OperationKeys.UPDATE]: dbDecorators.OperationKeys.UPDATE,
+        [dbDecorators.OperationKeys.DELETE]: dbDecorators.OperationKeys.DELETE
+    };
+    const WindowColorSchemes = {
+        light: "light",
+        dark: "dark",
+        undefined: "undefined"
+    };
+    class RenderingError extends dbDecorators.InternalError {
+        constructor(msg) {
+            super(msg, RenderingError.name);
+        }
+    }
+    const isClassConstructor = fn => typeof fn === "function" && /^class\s/.test(String(fn));
+    function getUIAttributeKey(prop, key) {
+        return decoration.Metadata.key(UIKeys.REFLECT, decoration.DecorationKeys.PROPERTIES, prop, key);
+    }
+    function formatByType(type, value, ...args) {
+        if (type === UIKeys.DATE) {
+            if (!value) return "";
+            const format = args.shift() || HTML5DateFormat;
+            return decoratorValidation.formatDate(new Date(value), format);
+        }
+        return value;
+    }
+    function parseValueByType(type, value, fieldProps) {
+        let result = undefined;
+        switch (type) {
+          case Array.name:
+            {
+                const parsed = Array.isArray(value) ? value.map(v => parseValueByType(decoratorValidation.ReservedModels.STRING.name.toLowerCase(), v, fieldProps)) : [ value ];
+                result = parsed.join(",");
+                break;
+            }
+
+          case HTML5InputTypes.NUMBER:
+            result = parseToNumber(value);
+            break;
+
+          case HTML5InputTypes.DATE:
+            {
+                const format = fieldProps.format;
+                if (value && `${value}`.trim().length) {
+                    result = typeof value === decoratorValidation.ReservedModels.NUMBER.name.toLowerCase() ? new Date(value) : value ? format ? decoratorValidation.parseDate(format, value) : new Date(value) : undefined;
+                }
+                break;
+            }
+
+          default:
+            result = typeof value === decoratorValidation.ReservedModels.OBJECT.name.toLowerCase() ? Array.isArray(value) ? value.join(",") : JSON.stringify(value) : typeof value === decoratorValidation.ReservedModels.BOOLEAN.name.toLowerCase() ? value : typeof value === decoratorValidation.ReservedModels.STRING.name.toLowerCase() ? escapeHtml(value) : result;
+        }
+        if (typeof result === "undefined") {
+            throw new dbDecorators.InternalError(`Failed to parse value of type ${type} from ${typeof value} - ${value}`);
+        }
+        return result;
+    }
+    function parseToNumber(value) {
+        if (typeof value === "number" && !isNaN(value)) return value;
+        const parsed = Number(value);
+        if (!isNaN(parsed)) return parsed;
+        return undefined;
+    }
+    function escapeHtml(value) {
+        if (!value) return value;
+        const tagsToReplace = {
+            "&": "&amp;",
+            "<": "&lt;",
+            ">": "&gt;"
+        };
+        return `${value}`.replace(/[&<>]/g, tag => tagsToReplace[tag] || tag);
+    }
+    function revertHtml(value) {
+        const tagsToReplace = {
+            "&amp;": "&",
+            "&lt;": "<",
+            "&gt;": ">"
+        };
+        return `${value}`.replace(/&lt;|&gt;|&amp;/g, tag => tagsToReplace[tag] || tag);
+    }
+    function generateUIModelID(model) {
+        let id = Date.now();
+        try {
+            const pk = decoratorValidation.Model.pk(model.constructor);
+            if (pk) id = model[decoratorValidation.Model.pk(model.constructor)];
+        } catch (e) {}
+        const name = model.constructor.name;
+        return `${name}-${id}`;
+    }
+    class RenderingEngine {
+        static {
+            this.cache = {};
+        }
+        constructor(flavour) {
+            this.flavour = flavour;
+            this.initialized = false;
+            RenderingEngine.register(this);
+            console.log(`decaf's ${flavour} rendering engine loaded`);
+        }
+        translate(key, toView = true) {
+            if (toView) {
+                switch (key) {
+                  case decoratorValidation.ReservedModels.STRING.name.toLowerCase():
+                    return HTML5InputTypes.TEXT;
+
+                  case decoratorValidation.ReservedModels.NUMBER.name.toLowerCase():
+                  case decoratorValidation.ReservedModels.BIGINT.name.toLowerCase():
+                    return HTML5InputTypes.NUMBER;
+
+                  case decoratorValidation.ReservedModels.BOOLEAN.name.toLowerCase():
+                    return HTML5InputTypes.CHECKBOX;
+
+                  case decoratorValidation.ReservedModels.DATE.name.toLowerCase():
+                    return HTML5InputTypes.DATE;
+                }
+            } else {
+                switch (key) {
+                  case HTML5InputTypes.SELECT:
+                  case HTML5InputTypes.TEXT:
+                  case HTML5InputTypes.EMAIL:
+                  case HTML5InputTypes.COLOR:
+                  case HTML5InputTypes.PASSWORD:
+                  case HTML5InputTypes.TEL:
+                  case HTML5InputTypes.URL:
+                  case HTML5InputTypes.SEARCH:
+                  case HTML5InputTypes.HIDDEN:
+                  case HTML5InputTypes.TEXTAREA:
+                  case HTML5InputTypes.RADIO:
+                    return decoratorValidation.ReservedModels.STRING.name.toLowerCase();
+
+                  case HTML5InputTypes.NUMBER:
+                    return decoratorValidation.ReservedModels.NUMBER.name.toLowerCase();
+
+                  case HTML5InputTypes.CHECKBOX:
+                    return decoratorValidation.ReservedModels.BOOLEAN.name.toLowerCase();
+
+                  case HTML5InputTypes.DATE:
+                  case HTML5InputTypes.DATETIME_LOCAL:
+                  case HTML5InputTypes.TIME:
+                    return decoratorValidation.ReservedModels.DATE.name.toLowerCase();
+                }
+            }
+            return key;
+        }
+        getClassDecoratorsMetadata(model) {
+            return [ decoratorValidation.Model.uiModelOf(model.constructor), decoratorValidation.Model.uiListModelOf(model.constructor), decoratorValidation.Model.uiHandlersFor(model.constructor), decoratorValidation.Model.uiLayoutOf(model.constructor) ].filter(Boolean);
+        }
+        sortChildrenByOrder(children = []) {
+            return children.sort((a, b) => {
+                const aOrder = a.props?.order ?? 0;
+                const bOrder = b.props?.order ?? 0;
+                const weight = v => v === UIKeys.FIRST ? 0 : typeof v === decoratorValidation.Primitives.NUMBER ? 1 : v === UIKeys.LAST ? children.length + children.indexOf(b) : 1;
+                const aWeight = weight(aOrder);
+                const bWeight = weight(bOrder);
+                if (aWeight !== bWeight) {
+                    return aWeight - bWeight;
+                }
+                if (aWeight === 1 && typeof aOrder === decoratorValidation.Primitives.NUMBER && typeof bOrder === decoratorValidation.Primitives.NUMBER) {
+                    return aOrder - bOrder;
+                }
+                return 0;
+            });
+        }
+        isCustomValidator(key) {
+            return !Object.values(decoratorValidation.ValidationKeys).includes(key) && !Object.values(UIKeys).includes(key);
+        }
+        isValidatableByType(key) {
+            return Object.keys(ValidatableByType).includes(key);
+        }
+        isValidatableByAttribute(key) {
+            return Object.keys(ValidatableByAttribute).includes(key);
+        }
+        toAttributeValue(key, value) {
+            if (!Object.keys(ValidatableByAttribute).includes(key)) throw new Error(`Invalid attribute key "${key}". Expected one of: ${Object.keys(ValidatableByAttribute).join(", ")}.`);
+            return key === UIKeys.REQUIRED ? true : value[key];
+        }
+        toFieldDefinition(model, globalProps = {}, generateId = true) {
+            const {inheritProps: inheritProps, ...globalPropsWithoutInherits} = globalProps;
+            globalProps = globalPropsWithoutInherits;
+            const classDecorators = this.getClassDecoratorsMetadata(model);
+            if (!classDecorators.length) throw new RenderingError(`No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`);
+            const classDecorator = Object.assign({}, ...classDecorators, inheritProps ? inheritProps : {});
+            const {tag: tag, props: props, item: item, handlers: handlers} = classDecorator;
+            const uiDecorators = decoratorValidation.Model.uiPropertiesOf(model.constructor);
+            let children;
+            let childProps = item?.props || {};
+            let mapper = {};
+            const getPath = (parent, prop) => parent ? [ parent, prop ].join(".") : prop;
+            if (uiDecorators) {
+                const validationDecorators = decoration.Metadata.get(model.constructor, decoratorValidation.ValidationKeys.REFLECT) || {};
+                for (const key of uiDecorators) {
+                    const decs = decoratorValidation.Model.uiDecorationOf(model.constructor, key);
+                    let type;
+                    try {
+                        type = decoratorValidation.Model.uiTypeOf(model.constructor, key);
+                    } catch (e) {
+                        if (!(e instanceof dbDecorators.NotFoundError)) throw e;
+                    }
+                    const hasHideOnDecorator = decoratorValidation.Model.uiIsHidden(model.constructor, key);
+                    if (hasHideOnDecorator) {
+                        const hasUiElementDecorator = decoratorValidation.Model.uiElementOf(model.constructor, key);
+                        if (!hasUiElementDecorator) throw new RenderingError(`@uielement no found in "${key}". It is required to use hiddenOn decorator.`);
+                    }
+                    const sorted = Object.entries(decs).map(([k, v]) => ({
+                        key: k,
+                        props: v
+                    })).sort(a => [ UIKeys.ELEMENT, UIKeys.CHILD ].includes(a.key) ? -1 : 1);
+                    sorted.forEach(dec => {
+                        if (!dec) throw new RenderingError(`No decorator found`);
+                        switch (dec.key) {
+                          case UIKeys.PROP:
+                            {
+                                childProps[key] = dec.props;
+                                break;
+                            }
+
+                          case UIKeys.CHILD:
+                            {
+                                const modelName = dec.props?.props?.name || key;
+                                try {
+                                    const isPropertyModel = decoratorValidation.Model.isModel(decoratorValidation.Model.build({}, modelName)) || decoratorValidation.Model.isPropertyModel(model, modelName);
+                                    if (!isPropertyModel) throw new RenderingError(`Child "${modelName}" must be a model.`);
+                                } catch (e) {
+                                    throw new RenderingError(`Child "${modelName}" must be a model.`);
+                                }
+                                let Clazz;
+                                const submodel = model[key];
+                                const constructable = typeof submodel === "object" && submodel !== null && !Array.isArray(submodel);
+                                if (!constructable) {
+                                    const clazzName = dec.props.props?.name;
+                                    Clazz = new (decoratorValidation.Model.get(clazzName));
+                                }
+                                children = children || [];
+                                const childrenGlobalProps = Object.assign({}, globalProps || {}, {
+                                    model: Clazz
+                                }, {
+                                    inheritProps: dec.props,
+                                    childOf: getPath(globalProps?.childOf, key)
+                                });
+                                const childDefinition = this.toFieldDefinition(submodel || Clazz, childrenGlobalProps, false);
+                                const {inheritProps: inheritProps} = childrenGlobalProps;
+                                if (inheritProps) childDefinition.props = Object.assign({}, childDefinition.props, inheritProps.props || {});
+                                children.push(childDefinition);
+                                break;
+                            }
+
+                          case UIKeys.UILISTPROP:
+                            {
+                                mapper = mapper || {};
+                                const decProps = dec.props;
+                                if (decProps.name) mapper[decProps.name] = typeof decProps?.props === "object" && UIKeys.SEQUENCE in decProps.props ? decProps.props : key;
+                                const props = Object.assign({}, classDecorator.props?.item || {}, item?.props || {}, decProps?.props || {}, globalProps);
+                                childProps = {
+                                    tag: item?.tag || props.render || "",
+                                    props: Object.assign({}, childProps?.props, {
+                                        mapper: mapper
+                                    }, props)
+                                };
+                                break;
+                            }
+
+                          case UIKeys.EVENTS:
+                          case UIKeys.HIDDEN:
+                          case UIKeys.HIDE_FOR:
+                          case UIKeys.SHOW_FOR:
+                          case UIKeys.PAGE:
+                          case UIKeys.ORDER:
+                          case UIKeys.UILAYOUTPROP:
+                          case UIKeys.ELEMENT:
+                            {
+                                children = children || [];
+                                const uiProps = dec.props;
+                                const visibilityProps = dec.key === UIKeys.HIDE_FOR ? {
+                                    hideFor: dec.props
+                                } : dec.key === UIKeys.SHOW_FOR ? {
+                                    showFor: dec.props
+                                } : {};
+                                const props = Object.assign({}, childProps?.props, uiProps.props || {}, visibilityProps, uiProps?.props?.name ? {
+                                    path: getPath(globalProps?.childOf, uiProps.props.name),
+                                    childOf: undefined
+                                } : {}, globalProps, {
+                                    name: uiProps.props?.name || key
+                                });
+                                if (dec.key === UIKeys.ELEMENT) {
+                                    const childDefinition = {
+                                        tag: uiProps.tag || childProps?.tag || tag || "",
+                                        props: props
+                                    };
+                                    const validationDecs = validationDecorators[key];
+                                    if (validationDecs) {
+                                        for (const dec of Object.entries(validationDecs).map(([k, v]) => ({
+                                            key: k,
+                                            props: v
+                                        }))) {
+                                            if (this.isValidatableByAttribute(dec.key)) {
+                                                childDefinition.props[this.translate(dec.key)] = this.toAttributeValue(dec.key, dec.props);
+                                                continue;
+                                            }
+                                            if (this.isValidatableByType(dec.key)) {
+                                                if (dec.key === HTML5InputTypes.DATE) {
+                                                    childDefinition.props[UIKeys.FORMAT] = dec.props.format || HTML5DateFormat;
+                                                }
+                                                childDefinition.props[UIKeys.TYPE] = dec.key;
+                                                continue;
+                                            }
+                                            if (this.isCustomValidator(dec.key)) {
+                                                props[UIKeys.SUB_TYPE] = dec.key;
+                                                if (dec.props?.message) {
+                                                    props[UIKeys.VALIDATION_MESSAGE] = dec.props.message;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!childDefinition.props[UIKeys.TYPE]) {
+                                        const basicType = decoration.Metadata.type(model.constructor, key).name;
+                                        childDefinition.props[UIKeys.TYPE] = this.translate(basicType.toLowerCase(), true);
+                                    }
+                                    childDefinition.props.value = formatByType(childDefinition.props[UIKeys.TYPE], model[key], childDefinition.props[UIKeys.FORMAT]);
+                                    children.push(childDefinition);
+                                } else {
+                                    const child = children.find(c => c.props?.name === key || [ UIKeys.UILAYOUTPROP, UIKeys.PAGE, UIKeys.EVENTS ].includes(dec.key) && (c.props?.childOf === key || c.props?.childOf?.endsWith(`.${key}`)));
+                                    if (child) {
+                                        if (dec.key === UIKeys.HIDE_FOR || dec.key === UIKeys.SHOW_FOR) {
+                                            child.props = Object.assign({}, child.props, visibilityProps);
+                                        } else if (dec.key !== UIKeys.UILAYOUTPROP) {
+                                            child.props = Object.assign({}, child.props, {
+                                                [dec.key]: uiProps
+                                            });
+                                        } else {
+                                            const {row: row, col: col, props: props} = dec.props;
+                                            child.props = Object.assign({}, props || {}, child.props, row, col);
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+
+                          default:
+                            throw new RenderingError(`Invalid key: ${dec.key}`);
+                        }
+                    });
+                }
+            }
+            globalProps = Object.assign({}, props, globalProps, {
+                handlers: handlers || {}
+            });
+            const currentNamespaces = new Set([ ...Array.isArray(globalProps?.namespaces) ? globalProps.namespaces : [], ...typeof globalProps?.namespace === "string" ? [ globalProps.namespace ] : [] ].filter(Boolean));
+            const operation = globalProps?.operation;
+            children = this.sortChildrenByOrder(children).filter(item => {
+                const hiddenOn = item?.props?.hidden || [];
+                if (hiddenOn.length > 0 && hiddenOn.includes(operation)) {
+                    return false;
+                }
+                const hideFor = item?.props?.hideFor || [];
+                const showFor = item?.props?.showFor || [];
+                if (hideFor.length > 0 && [ ...currentNamespaces ].some(namespace => hideFor.includes(namespace))) {
+                    return false;
+                }
+                if (showFor.length > 0 && ![ ...currentNamespaces ].some(namespace => showFor.includes(namespace))) {
+                    return false;
+                }
+                return true;
+            });
+            const result = {
+                tag: tag,
+                item: childProps,
+                props: globalProps,
+                children: children?.length ? children : undefined
+            };
+            if (generateId) result.rendererId = generateUIModelID(model);
+            return result;
+        }
+        static register(engine) {
+            if (engine.flavour in this.cache) throw new dbDecorators.InternalError(`Rendering engine under ${engine.flavour} already exists`);
+            this.cache[engine.flavour] = engine;
+            this.current = engine;
+        }
+        static getOrBoot(obj) {
+            if (obj instanceof RenderingEngine) return obj;
+            const engine = new obj;
+            engine.initialize();
+            return engine;
+        }
+        static get(flavour) {
+            if (!flavour) return this.getOrBoot(this.current);
+            if (!(flavour in this.cache)) throw new dbDecorators.InternalError(`Rendering engine under ${flavour} does not exist`);
+            return this.getOrBoot(this.cache[flavour]);
+        }
+        static render(model, ...args) {
+            const constructor = decoratorValidation.Model.get(model.constructor.name) || decoratorValidation.Model.fromObject(model);
+            if (!constructor) throw new dbDecorators.InternalError("No model registered found");
+            const flavour = decoratorValidation.Model.renderedBy(model.constructor);
+            return RenderingEngine.get(flavour).render(model, ...args);
+        }
+    }
+    function hideOn(...operations) {
+        return function hideOn(object, propertyKey) {
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.HIDDEN), operations)(object, propertyKey);
+        };
+    }
+    function hideFor(...namespaces) {
+        return function hideFor(object, propertyKey) {
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.HIDE_FOR), namespaces)(object, propertyKey);
+        };
+    }
+    function showFor(...namespaces) {
+        return function showFor(object, propertyKey) {
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.SHOW_FOR), namespaces)(object, propertyKey);
+        };
+    }
+    function renderIf(...namespaces) {
+        return showFor(...namespaces);
+    }
+    function uiorder(order = UIKeys.FIRST) {
+        return function uiorder(object, propertyKey) {
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.ORDER), order)(object, propertyKey);
+        };
+    }
+    function hidden() {
+        return hideOn(dbDecorators.OperationKeys.CREATE, dbDecorators.OperationKeys.READ, dbDecorators.OperationKeys.UPDATE, dbDecorators.OperationKeys.DELETE);
+    }
+    function uielement(tag, props, serialize = false) {
+        return (original, propertyKey) => {
+            if (typeof tag === "object") {
+                props = tag;
+                tag = "";
+            }
+            const metadata = {
+                tag: tag,
+                serialize: serialize,
+                props: Object.assign({}, props || {}, {
+                    name: propertyKey
+                })
+            };
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.ELEMENT), metadata)(original, propertyKey);
+        };
+    }
+    function uiprop(propName = undefined, stringify = false) {
+        return (target, propertyKey) => {
+            const metadata = {
+                name: propName || propertyKey,
+                stringify: stringify
+            };
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.PROP), metadata)(target, propertyKey);
+        };
+    }
+    function uichild(clazz, tag, props = {}, isArray = false, serialize = false) {
+        return (target, propertyKey) => {
+            const metadata = {
+                tag: tag,
+                serialize: serialize,
+                props: Object.assign({}, props || {}, {
+                    name: clazz || propertyKey
+                }, isArray ? {
+                    customTypes: [ Array.name ],
+                    multiple: true
+                } : {
+                    multiple: props?.multiple || false
+                })
+            };
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.CHILD), metadata)(target, propertyKey);
+        };
+    }
+    function uilistprop(propName = undefined, props) {
+        return (target, propertyKey) => {
+            const metadata = {
+                name: propName || propertyKey,
+                props: props || {}
+            };
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILISTPROP), metadata)(target, propertyKey);
+        };
+    }
+    function uilayoutprop(col = 1, row = 1) {
+        return (target, propertyKey) => {
+            const metadata = {
+                name: propertyKey,
+                props: Object.assign({}, {
+                    row: row,
+                    col: col
+                })
+            };
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILAYOUTPROP), metadata)(target, propertyKey);
+        };
+    }
+    function uipageprop(page = 1) {
+        return function uipageprop(original, propertyKey) {
+            return decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.PAGE), page)(original, propertyKey);
+        };
+    }
+    function uion(event, handler) {
+        return function uion(original, propertyKey) {
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.EVENTS), {
+                ...typeof event === "object" ? event : {
+                    [event]: handler
+                }
+            })(original, propertyKey);
+        };
+    }
+    function uionclick(handler) {
+        return uion("handleClick", handler);
+    }
+    function uionrender(handler) {
+        return uion("render", handler);
+    }
+    function uitablecol(sequence = UIKeys.LAST, valueParserFn) {
+        return (target, propertyKey) => {
+            const metadata = {
+                name: propertyKey,
+                props: {
+                    sequence: sequence,
+                    ...!valueParserFn ? {} : {
+                        valueParserFn: valueParserFn
+                    }
+                }
+            };
+            decoration.propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILISTPROP), metadata)(target, propertyKey);
+        };
+    }
+    class UIValidator extends decoratorValidation.Validator {
+        getMessage(message, ...args) {
+            if (UIValidator.translateService) return UIValidator.translateService.translate(message, ...args);
+            return super.getMessage(message, ...args);
+        }
+    }
+    class DecafComponent extends logging.LoggedClass {
+        constructor() {
+            super();
+            this.enableDarkMode = true;
+            this.isDarkMode = false;
+            this.item = {
+                tag: ""
+            };
+            this.props = {};
+            this.route = "";
+            this.borders = false;
+            this.OperationKeys = dbDecorators.OperationKeys;
+            this.initialized = false;
+            this.events = {};
+            this.handlers = {};
+        }
+        get repository() {
+            return this._repository;
+        }
+        set repository(repository) {
+            this._repository = repository;
+        }
+        async render(...args) {
+            this.log.for(this.render).info(`render for ${this.componentName} with ${JSON.stringify(args)}`);
+        }
+        async refresh(...args) {
+            this.log.for(this.refresh).info(`Refresh called with args: ${args}`);
+        }
+        async initialize(...args) {
+            this.initialized = true;
+        }
+        async translate(...args) {
+            this.log.for(this.translate).info(`translate for ${this.componentName} with ${JSON.stringify(args)}`);
+        }
+        async preview(...args) {
+            this.log.for(this.preview).debug(`Preview called with args: ${args}`);
+        }
+        async submit(...args) {
+            this.log.for(this.submit).info(`submit for ${this.componentName} with ${JSON.stringify(args)}`);
+        }
+        parseHandlers(handlers, instance) {
+            const result = {};
+            Object.entries(handlers).forEach(([key, fn]) => {
+                if (isClassConstructor(fn)) {
+                    const clazz = new fn;
+                    const event = key in clazz ? clazz[key] : clazz.handle;
+                    result[key] = event;
+                    instance.handlers[key] = event;
+                } else {
+                    result[key] = fn;
+                    instance.handlers[key] = fn;
+                }
+            });
+            return result;
+        }
+        parseEvents(events, instance) {
+            const result = {};
+            Object.entries(events).forEach(([key, fn]) => {
+                const name = key;
+                const evt = fn();
+                if (isClassConstructor(evt)) {
+                    const fn = (new evt)[key];
+                    if (fn) {
+                        result[name] = fn;
+                        instance.events[name] = fn;
+                    }
+                } else {
+                    result[name] = fn;
+                    instance.events[name] = fn;
+                }
+            });
+            return result;
+        }
+    }
+    class DecafEventHandler extends DecafComponent {
+        constructor() {
+            super();
+        }
+        handle(...args) {
+            this.log.for(this.handle).info(`component ${this.componentName} handling ${JSON.stringify(args)}`);
+        }
+        handleClick(...args) {
+            this.log.for(this.handleClick).info(`component ${this.componentName} handling click ${JSON.stringify(args)}`);
+        }
+        handleAction(...args) {
+            this.log.for(this.handleAction).info(`component ${this.componentName} handling action ${JSON.stringify(args)}`);
+        }
+    }
+    class DecafTranslateService extends logging.LoggedClass {
+        translate(key, params) {
+            this.log.for(this.translate).info(`Must translate ${key} with params ${JSON.stringify(params || {})}`);
+        }
+        instant(key, params) {
+            this.log.for(this.instant).info(`Must translate ${key} with params ${JSON.stringify(params || {})}`);
+        }
+    }
+    decoratorValidation.Model.prototype.render = function(...args) {
+        return RenderingEngine.render(this, ...args);
+    };
+    decoratorValidation.Model.renderedBy = function(model) {
+        return decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, UIKeys.RENDERED_BY));
+    }.bind(decoratorValidation.Model);
+    decoratorValidation.Model.uiPropertiesOf = function(model) {
+        const meta = decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, decoration.DecorationKeys.PROPERTIES));
+        if (!meta) return undefined;
+        return Object.keys(meta);
+    }.bind(decoratorValidation.Model);
+    decoratorValidation.Model.uiDecorationOf = function(model, prop, key) {
+        const meta = decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, decoration.DecorationKeys.PROPERTIES, prop));
+        if (!meta) return undefined;
+        if (!key) return meta;
+        return meta[key];
+    };
+    decoratorValidation.Model.uiModelOf = function(model) {
+        return decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UIMODEL));
+    };
+    decoratorValidation.Model.uiElementOf = function(model, prop) {
+        return decoration.Metadata.get(model, getUIAttributeKey(prop, UIKeys.ELEMENT));
+    };
+    decoratorValidation.Model.uiListModelOf = function(model) {
+        return decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UILISTMODEL));
+    };
+    decoratorValidation.Model.uiHandlersFor = function(model) {
+        return decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, UIKeys.HANDLERS));
+    };
+    decoratorValidation.Model.uiLayoutOf = function(model) {
+        return decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UILAYOUT));
+    };
+    decoratorValidation.Model.uiIsHidden = function(model, prop) {
+        return !!decoration.Metadata.get(model, getUIAttributeKey(prop, UIKeys.HIDDEN));
+    };
+    decoratorValidation.Model.uiIsHiddenOn = function(model, prop, op) {
+        const meta = decoration.Metadata.get(model, getUIAttributeKey(prop, UIKeys.HIDDEN));
+        if (!meta) return false;
+        if (!op) return meta;
+        return meta.includes(op);
+    };
+    decoratorValidation.Model.uiTypeOf = function(model, prop) {
+        const meta = decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, decoration.DecorationKeys.PROPERTIES, prop));
+        if (!meta) throw new dbDecorators.NotFoundError(`No metadata found for property '${prop}' on model '${model.name}'`);
+        const keys = Object.keys(meta).filter(k => [ UIKeys.PROP, UIKeys.ELEMENT, UIKeys.CHILD ].includes(k));
+        if (keys.length === 0) throw new dbDecorators.NotFoundError(`No UI type metadata found for property '${prop}' on model '${model.name}'`);
+        if (keys.length > 1) throw new RenderingError(`Only one type of decoration is allowed. Please choose between @uiprop, @uichild or @uielement`);
+        return meta[keys[0]];
+    };
+    decoratorValidation.Model.uiListItems = function(model) {
+        const meta = decoration.Metadata.get(model, decoration.Metadata.key(UIKeys.REFLECT, decoration.DecorationKeys.PROPERTIES));
+        if (!meta) return undefined;
+        return Object.keys(meta);
+    }.bind(decoratorValidation.Model);
+    function uimodel(tag, props) {
+        return (original, propertyKey) => {
+            const meta = {
+                tag: tag || original.name,
+                props: props
+            };
+            return decoration.metadata(decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UIMODEL), meta)(original);
+        };
+    }
+    function renderedBy(engine) {
+        return decoration.apply(decoration.metadata(decoration.Metadata.key(UIKeys.REFLECT, UIKeys.RENDERED_BY), engine));
+    }
+    function uilistmodel(name, props) {
+        return (original, propertyKey) => {
+            const meta = {
+                item: {
+                    tag: name || original.name,
+                    props: props
+                }
+            };
+            return decoration.metadata(decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UILISTMODEL), meta)(original);
+        };
+    }
+    function uihandlers(props) {
+        return original => {
+            const meta = {
+                handlers: props
+            };
+            return decoration.metadata(decoration.Metadata.key(UIKeys.REFLECT, UIKeys.HANDLERS), meta)(original);
+        };
+    }
+    function uilayout(tag, colsMode = 1, rows = 1, props = {}) {
+        const config = Object.assign({
+            ...typeof colsMode === "boolean" ? {
+                flexMode: colsMode,
+                cols: 1
+            } : {
+                flexMode: false,
+                cols: colsMode
+            },
+            rows: rows,
+            ...Object.assign({
+                breakpoint: exports.UIMediaBreakPoints.LARGE
+            }, props)
+        });
+        return (original, propertyKey) => {
+            decoration.metadata(decoration.Metadata.key(UIKeys.REFLECT, UIKeys.UILAYOUT), config)(original);
+            return uimodel(tag, config)(original, propertyKey);
+        };
+    }
+    function uisteppedmodel(tag, pages = 1, paginated = false, props = {}) {
+        let pageTitles = [];
+        if (typeof pages === "object") {
+            pageTitles = pages;
+            pages = pageTitles.length;
+        }
+        return uimodel(tag, {
+            pages: pages,
+            paginated: paginated,
+            pageTitles: pageTitles,
+            props: props
+        });
+    }
+    const prototype = decoratorValidation.ModelBuilder.prototype;
+    if (!prototype.decorateClass) {
+        prototype.decorateClass = function(decorator) {
+            if (!this._classDecorators) {
+                this._classDecorators = [];
+            }
+            this._classDecorators.push(decorator);
+            return this;
+        };
+    }
+    prototype.uimodel = function(tag, props) {
+        return this.decorateClass(uimodel(tag, props));
+    };
+    prototype.renderedBy = function(engine) {
+        return this.decorateClass(renderedBy(engine));
+    };
+    prototype.uilistmodel = function(name, props) {
+        return this.decorateClass(uilistmodel(name, props));
+    };
+    prototype.uihandlers = function(props) {
+        return this.decorateClass(uihandlers(props));
+    };
+    prototype.uilayout = function(tag, colsMode, rows, props) {
+        return this.decorateClass(uilayout(tag, colsMode, rows, props));
+    };
+    prototype.uisteppedmodel = function(tag, pages, paginated, props) {
+        return this.decorateClass(uisteppedmodel(tag, pages, paginated, props));
+    };
+    exports.DashKeys = void 0;
+    (function(DashKeys) {
+        DashKeys["ROOT"] = "dashboard";
+        DashKeys["COMPONENT"] = "dashboard.component";
+    })(exports.DashKeys || (exports.DashKeys = {}));
+    const DASH_COMPONENT_REGISTRY = new Set;
+    function registerDashComponent(ctor) {
+        DASH_COMPONENT_REGISTRY.add(ctor);
+    }
+    function dashComponents() {
+        return [ ...DASH_COMPONENT_REGISTRY ];
+    }
+    function resetDashComponentRegistry() {
+        DASH_COMPONENT_REGISTRY.clear();
+    }
+    function dashcomponent(tag, dash, props) {
+        function dashcomponent(tag, dash, props) {
+            const meta = {
+                tag: dash?.tag || tag,
+                ...dash,
+                defaultSize: dash?.defaultSize ?? {
+                    cols: 1,
+                    rows: 1
+                }
+            };
+            return function innerDashComponent(target) {
+                const result = decoration.apply(uimodel(tag, props), decoration.metadata(exports.DashKeys.COMPONENT, meta))(target);
+                registerDashComponent(target);
+                return result;
+            };
+        }
+        return decoration.Decoration.for(exports.DashKeys.COMPONENT).define({
+            decorator: dashcomponent,
+            args: [ tag, dash, props ]
+        }).apply();
+    }
+    function resolveModel(model) {
+        const resolved = decoration.Metadata.constr(model);
+        if (typeof resolved === "function") return resolved;
+        const fallback = model.constructor;
+        if (typeof fallback === "function") return fallback;
+        return model;
+    }
+    function dashComponentMetadataOf(model) {
+        const resolved = resolveModel(model);
+        return decoration.Metadata.get(resolved, exports.DashKeys.COMPONENT);
+    }
+    function dashComponentDefinitionOf(model) {
+        const resolved = resolveModel(model);
+        const meta = dashComponentMetadataOf(resolved) || {};
+        const tag = meta.tag || resolved.name;
+        return {
+            name: resolved.name,
+            tag: tag,
+            label: meta.label,
+            defaultSize: meta.defaultSize ?? {
+                cols: 1,
+                rows: 1
+            },
+            model: meta.model,
+            props: meta.props,
+            metadata: meta.metadata
+        };
+    }
+    const VERSION = "0.20.7";
+    const COMMIT = "f92e8d1";
+    const FULL_VERSION = "0.20.7-f92e8d1";
+    const PACKAGE_NAME = "@decaf-ts/ui-decorators";
+    decoration.Metadata.registerLibrary(PACKAGE_NAME, VERSION);
+    exports.ActionRoles = ActionRoles;
+    exports.COMMIT = COMMIT;
+    exports.ComponentEventNames = ComponentEventNames;
+    exports.DecafComponent = DecafComponent;
+    exports.DecafEventHandler = DecafEventHandler;
+    exports.DecafTranslateService = DecafTranslateService;
+    exports.ElementPositions = ElementPositions;
+    exports.ElementSizes = ElementSizes;
+    exports.FULL_VERSION = FULL_VERSION;
+    exports.HTML5CheckTypes = HTML5CheckTypes;
+    exports.HTML5DateFormat = HTML5DateFormat;
+    exports.HTML5InputTypes = HTML5InputTypes;
+    exports.LayoutGridGaps = LayoutGridGaps;
+    exports.PACKAGE_NAME = PACKAGE_NAME;
+    exports.RenderingEngine = RenderingEngine;
+    exports.RenderingError = RenderingError;
+    exports.TransactionHooks = TransactionHooks;
+    exports.UIKeys = UIKeys;
+    exports.UIValidator = UIValidator;
+    exports.VERSION = VERSION;
+    exports.ValidatableByAttribute = ValidatableByAttribute;
+    exports.ValidatableByType = ValidatableByType;
+    exports.WindowColorSchemes = WindowColorSchemes;
+    exports.dashComponentDefinitionOf = dashComponentDefinitionOf;
+    exports.dashComponentMetadataOf = dashComponentMetadataOf;
+    exports.dashComponents = dashComponents;
+    exports.dashcomponent = dashcomponent;
+    exports.escapeHtml = escapeHtml;
+    exports.formatByType = formatByType;
+    exports.generateUIModelID = generateUIModelID;
+    exports.getUIAttributeKey = getUIAttributeKey;
+    exports.hidden = hidden;
+    exports.hideFor = hideFor;
+    exports.hideOn = hideOn;
+    exports.isClassConstructor = isClassConstructor;
+    exports.parseToNumber = parseToNumber;
+    exports.parseValueByType = parseValueByType;
+    exports.registerDashComponent = registerDashComponent;
+    exports.renderIf = renderIf;
+    exports.renderedBy = renderedBy;
+    exports.resetDashComponentRegistry = resetDashComponentRegistry;
+    exports.revertHtml = revertHtml;
+    exports.showFor = showFor;
+    exports.uichild = uichild;
+    exports.uielement = uielement;
+    exports.uihandlers = uihandlers;
+    exports.uilayout = uilayout;
+    exports.uilayoutprop = uilayoutprop;
+    exports.uilistmodel = uilistmodel;
+    exports.uilistprop = uilistprop;
+    exports.uimodel = uimodel;
+    exports.uion = uion;
+    exports.uionclick = uionclick;
+    exports.uionrender = uionrender;
+    exports.uiorder = uiorder;
+    exports.uipageprop = uipageprop;
+    exports.uiprop = uiprop;
+    exports.uisteppedmodel = uisteppedmodel;
+    exports.uitablecol = uitablecol;
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ui-decorators.cjs","sources":["../src/ui/constants.ts","../src/ui/errors.ts","../src/ui/utils.ts","../src/ui/Rendering.ts","../src/ui/decorators.ts","../src/ui/UIValidator.ts","../src/ui/DecafComponent.ts","../src/ui/DecafEventHandler.ts","../src/ui/DecafTranslateService.ts","../src/model/overrides.ts","../src/model/decorators.ts","../src/overrides/ModelBuilderExtensions.ts","../src/dashboard/constants.ts","../src/dashboard/registry.ts","../src/dashboard/decorators.ts","../src/dashboard/reader.ts","../src/index.ts"],"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  DateValidator,\n  DiffValidator,\n  EmailValidator,\n  EqualsValidator,\n  GreaterThanOrEqualValidator,\n  GreaterThanValidator,\n  LessThanOrEqualValidator,\n  LessThanValidator,\n  MaxLengthValidator,\n  MaxValidator,\n  MinLengthValidator,\n  MinValidator,\n  PasswordValidator,\n  PatternValidator,\n  RequiredValidator,\n  StepValidator,\n  URLValidator,\n  ValidationKeys,\n  Validator,\n} from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\n\nexport enum UIMediaBreakPoints {\n  SMALL = \"small\",\n  MEDIUM = \"medium\",\n  LARGE = \"large\",\n  XLARGE = \"xlarge\",\n}\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} UILISTMODEL - 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: `ui`,\n  UIMODEL: \"uimodel\",\n  RENDERED_BY: \"rendered-by\",\n  ELEMENT: \"uielement\",\n  PROP: \"uiprop\",\n  CHILD: \"uichild\",\n  NAME: \"name\",\n  NAME_PREFIX: \"input-\",\n  VALIDATION_MESSAGE: \"validationMessage\",\n\n  UILISTMODEL: \"uilistmodel\",\n  UILISTPROP: \"uilistprop\",\n  UILAYOUT: \"uilayout\",\n  UILAYOUTPROP: \"uilayoutprop\",\n  HANDLERS: \"handlers\",\n\n  TYPE: \"type\",\n  SUB_TYPE: \"subType\",\n\n  HIDDEN: \"hidden\",\n  HIDE_FOR: \"hide-for\",\n  SHOW_FOR: \"show-for\",\n  RENDER_IF: \"render-if\",\n  FORMAT: \"format\",\n  ORDER: \"order\",\n  PAGE: \"page\",\n  EVENTS: \"events\",\n\n  FIRST: \"first\",\n  LAST: \"last\",\n\n  READ_ONLY: \"readonly\",\n  SEQUENCE: \"sequence\",\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  TEXTAREA: \"textarea\",\n  SELECT: \"select\",\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: string[] = [\n  HTML5InputTypes.CHECKBOX,\n  HTML5InputTypes.RADIO,\n];\n\n/**\n * @description Event name constants.\n * @summary Contains constants for standardized event names used throughout the application.\n * These constants ensure consistent event naming across components and make it easier to\n * track and handle events. Each constant represents a specific application event type.\n * @typedef {Object} ComponentEventNames\n * @property {string} BackButtonClickEvent - Event fired when back button navigation ends\n * @property {string} Render - Event after component initialize action occurs\n * @property {string} Refresh - Event fired when a refresh action occurs\n * @property {string} Click - Event fired when a click action occurs\n * @property {string} Change - Event fired when a change action occurs\n * @property {string} Submit - Event fired when a form submission occurs\n * @property {string} ValidationError - Event fired when a validation error occurs\n * @property {string} ThemeChange - Event fired when a theme change occurs\n * @property {string} FormGroupLoaded - Event fired when a reactve form group is loaded\n * @const ComponentEventNames\n */\nexport const ComponentEventNames = {\n  Render: \"render\",\n  BackButtonClickEvent: \"backButtonNavigationEndEvent\",\n  Refresh: \"RefreshEvent\",\n  Click: \"ClickEvent\",\n  Change: \"ChangeEvent\",\n  Submit: \"SubmitEvent\",\n  ValidationError: \"validationErrorEvent\",\n  ThemeChange: \"themeChangeEvent\",\n  FormGroupLoaded: \"formGroupLoadedEvent\",\n} as const;\n\n/**\n * @description Lifecycle hook labels for repository transactions.\n * @summary Provides canonical names for CRUD lifecycle callbacks so decorators and\n * components can register work before or after repository operations in a consistent way.\n * Each key maps to the string used when wiring transaction middleware.\n * @const TransactionHooks\n */\nexport const TransactionHooks = {\n  BeforeRead: \"beforeRead\",\n  AfterRead: \"afterRead\",\n  BeforeCreate: \"beforeCreate\",\n  AfterCreate: \"afterCreate\",\n  BeforeUpdate: \"beforeUpdate\",\n  AfterUpdate: \"afterUpdate\",\n  BeforeDelete: \"beforeDelete\",\n  AfterDelete: \"afterDelete\",\n} as const;\n\n/**\n * @description Standardized size tokens for UI elements.\n * @summary Defines the semantic size keywords supported by layout and form decorators.\n * These values feed rendering engines so components can express sizing in a uniform vocabulary.\n * @const ElementSizes\n */\nexport const ElementSizes = {\n  xsmall: \"xsmall\",\n  small: \"small\",\n  medium: \"medium\",\n  default: \"default\",\n  large: \"large\",\n  xLarge: \"xlarge\",\n  \"2xLarge\": \"2xlarge\",\n  auto: \"auto\",\n  expand: \"expand\",\n  block: \"block\",\n  half: \"half\",\n  full: \"full\",\n} as const;\n\n/**\n * @description Alignment keywords for element positioning.\n * @summary Supplies canonical position values (horizontal and vertical) that decorators can\n * use when aligning labels, controls, or helper text across components.\n * @const ElementPositions\n */\nexport const ElementPositions = {\n  left: \"left\",\n  center: \"center\",\n  right: \"right\",\n  top: \"top\",\n  bottom: \"bottom\",\n} as const;\n\n/**\n * @description Grid spacing presets for layout decorators.\n * @summary Maps human-readable gap sizes to the tokens interpreted by the rendering engine\n * when building CSS grid layouts, enabling predictable spacing across components.\n * @const LayoutGridGaps\n */\nexport const LayoutGridGaps = {\n  small: \"small\",\n  medium: \"medium\",\n  large: \"large\",\n  collapse: \"collapse\",\n  none: \"\",\n} as const;\n\n/**\n * @description Canonical action role identifiers for UI controls.\n * @summary Enumerates the semantic roles a button or action may represent so decorators and\n * renderers can attach consistent behaviors and styling (including CRUD verbs tied to\n * `OperationKeys`).\n * @const ActionRoles\n */\nexport const ActionRoles = {\n  cancel: \"cancel\",\n  confirm: \"confirm\",\n  submit: \"submit\",\n  clear: \"clear\",\n  back: \"back\",\n  [OperationKeys.CREATE]: OperationKeys.CREATE,\n  [OperationKeys.READ]: OperationKeys.READ,\n  [OperationKeys.UPDATE]: OperationKeys.UPDATE,\n  [OperationKeys.DELETE]: OperationKeys.DELETE,\n} as const;\n\n/**\n * @description Allowed color scheme tokens for windowed surfaces.\n * @summary Provides the supported theme identifiers exposed to consuming apps so they\n * can target light, dark, or unset window color schemes in a predictable way.\n * @const WindowColorSchemes\n */\nexport const WindowColorSchemes = {\n  light: \"light\",\n  dark: \"dark\",\n  undefined: \"undefined\",\n} as const;\n","import { InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when a rendering operation fails\n * @summary Specialized error for rendering failures in UI components\n * This error is thrown when the rendering engine encounters an error while\n * attempting to render a UI component or model.\n *\n * @param {string|Error} msg The error message or original error\n *\n * @class RenderingError\n * @extends BaseError\n * @category Errors\n *\n * @example\n * // Throwing a rendering error\n * try {\n *   // Rendering code that might fail\n *   if (!component.canRender()) {\n *     throw new RenderingError('Component cannot be rendered');\n *   }\n * } catch (error) {\n *   console.error('Rendering failed:', error.message);\n * }\n */\nexport class RenderingError extends InternalError {\n  /**\n   * @description Creates a new RenderingError instance\n   * @summary Initializes the error with a message or original error\n   * @param {string|Error} msg The error message or original error\n   */\n  constructor(msg: string | Error) {\n    super(msg, RenderingError.name);\n  }\n}\n","import {\n  formatDate,\n  Model,\n  parseDate,\n  ReservedModels,\n} from \"@decaf-ts/decorator-validation\";\nimport { HTML5DateFormat, HTML5InputTypes, UIKeys } from \"./constants\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { FieldProperties, UIFunctionLike } from \"./types\";\nimport { Constructor, DecorationKeys, Metadata } from \"@decaf-ts/decoration\";\n\n/**\n *\n * Type guard that verifies if a provided UI function-like value is a class constructor.\n */\nexport const isClassConstructor = <C>(\n  fn: UIFunctionLike | Constructor<C>\n): fn is Constructor<C> => {\n  return typeof fn === \"function\" && /^class\\s/.test(String(fn));\n};\n\n/**\n * Derives the metadata key for a UI attribute on a decorated property.\n *\n * @param prop - Property name decorated on the UI model.\n * @param key - Attribute identifier stored under the property metadata.\n * @returns Fully qualified metadata key scoped to `UIKeys.REFLECT`.\n */\nexport function getUIAttributeKey(prop: string, key: string) {\n  return Metadata.key(UIKeys.REFLECT, DecorationKeys.PROPERTIES, prop, key);\n}\n\n/**\n * @function formatByType\n *\n * @memberOf module:ui-decorators\n */\nexport function formatByType(\n  type: any,\n  value: any,\n  ...args: unknown[]\n): string | number {\n  if (type === UIKeys.DATE) {\n    if (!value) return \"\";\n    const format: string = (args.shift() as string) || HTML5DateFormat;\n    return formatDate(new Date(value), format);\n  }\n  return value;\n}\n\nexport function parseValueByType(\n  type: string,\n  value: string | number,\n  fieldProps: FieldProperties\n): string | number | Date {\n  let result: string | number | Date | undefined = undefined;\n  switch (type) {\n    case Array.name: {\n      const parsed = Array.isArray(value)\n        ? value.map((v) =>\n            parseValueByType(\n              ReservedModels.STRING.name.toLowerCase(),\n              v,\n              fieldProps\n            )\n          )\n        : [value];\n      result = parsed.join(\",\");\n      break;\n    }\n    case HTML5InputTypes.NUMBER:\n      result = parseToNumber(value);\n      break;\n    case HTML5InputTypes.DATE: {\n      const format: string | undefined = fieldProps.format;\n      if (value && `${value}`.trim().length) {\n        result =\n          typeof value === ReservedModels.NUMBER.name.toLowerCase()\n            ? new Date(value)\n            : value\n              ? format\n                ? parseDate(format, value)\n                : new Date(value)\n              : undefined;\n      }\n      break;\n    }\n    default:\n      result =\n        typeof value === ReservedModels.OBJECT.name.toLowerCase()\n          ? Array.isArray(value)\n            ? value.join(\",\")\n            : JSON.stringify(value)\n          : typeof value === ReservedModels.BOOLEAN.name.toLowerCase()\n            ? value\n            : typeof value === ReservedModels.STRING.name.toLowerCase()\n              ? escapeHtml(value as string)\n              : result;\n  }\n  if (typeof result === \"undefined\") {\n    throw new InternalError(\n      `Failed to parse value of type ${type} from ${typeof value} - ${value}`\n    );\n  }\n  return result;\n}\n\nexport function parseToNumber(value: string | number) {\n  if (typeof value === \"number\" && !isNaN(value)) return value;\n\n  const parsed = Number(value);\n  if (!isNaN(parsed)) return parsed;\n\n  return undefined;\n}\n\nexport function escapeHtml(value: string) {\n  if (!value) return value;\n\n  const tagsToReplace: Record<string, string> = {\n    \"&\": \"&amp;\",\n    \"<\": \"&lt;\",\n    \">\": \"&gt;\",\n  };\n  return `${value}`.replace(/[&<>]/g, (tag) => {\n    return tagsToReplace[tag] || tag;\n  });\n}\n\nexport function revertHtml(value: string) {\n  const tagsToReplace: Record<string, string> = {\n    \"&amp;\": \"&\",\n    \"&lt;\": \"<\",\n    \"&gt;\": \">\",\n  };\n\n  return `${value}`.replace(/&lt;|&gt;|&amp;/g, (tag) => {\n    return tagsToReplace[tag] || tag;\n  });\n}\n\nexport function generateUIModelID<M extends Model>(model: M) {\n  let id: string | number | bigint = Date.now();\n  try {\n    const pk = Model.pk(model.constructor as Constructor<M>);\n    if (pk)\n      id = model[\n        Model.pk(model.constructor as Constructor<M>) as keyof typeof model\n      ] as string | number;\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    // do nothing;\n  }\n  const name = model.constructor.name;\n  return `${name}-${id}`;\n}\n","import { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport {\n  HTML5DateFormat,\n  HTML5InputTypes,\n  UIKeys,\n  ValidatableByAttribute,\n  ValidatableByType,\n} from \"./constants\";\nimport {\n  CrudOperationKeys,\n  DecafSpinnerOptions,\n  DecafToastOptions,\n  FieldDefinition,\n  FieldProperties,\n  UIClassMetadata,\n  UIElementMetadata,\n  UIListItemElementMetadata,\n  UIListPropMetadata,\n  UIModelMetadata,\n  UIPropMetadata,\n  IPagedComponentProperties,\n} from \"./types\";\nimport { RenderingError } from \"./errors\";\nimport { formatByType, generateUIModelID } from \"./utils\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  Model,\n  ModelConstructor,\n  Primitives,\n  ReservedModels,\n  ValidationKeys,\n  ValidationMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { IDecafModal } from \"./interfaces/IDecafModal\";\nimport { DecafComponent } from \"./DecafComponent\";\n\nimport { IDecafSpinner } from \"./interfaces/IDecafSpinner\";\nimport { IDecafRouter } from \"./interfaces/IDecafRouter\";\nimport { IDecafToast } from \"./interfaces/IDecafToast\";\n\n/**\n * @description Abstract class for rendering UI components based on model metadata.\n * @summary The RenderingEngine class provides a framework for converting model metadata into UI field definitions.\n * It handles the translation of model properties to UI elements, applies validation rules, and manages different rendering flavors.\n * This class is designed to be extended by specific rendering implementations.\n *\n * @template T The type of the rendering result, defaults to void\n * @template R The type of the field definition, defaults to FieldDefinition<T>\n *\n * @param {string} flavour - The flavor of the rendering engine.\n *\n * @class RenderingEngine\n */\n/**\n * Represents the base abstraction for decaf rendering engines, handling engine registration,\n * initialization, model-to-field translation, and runtime rendering orchestration.\n * Implementations must provide initialization and rendering logic while leveraging the shared\n * metadata-driven conversion utilities supplied here.\n */\nexport abstract class RenderingEngine<T = void, R = FieldDefinition<T>> {\n  /**\n   * @description Cache for storing rendering engine instances or constructors.\n   * @private\n   * @static\n   */\n  private static cache: Record<\n    string,\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>\n  > = {};\n\n  /**\n   * @description The currently active rendering engine.\n   * @private\n   * @static\n   */\n  private static current:\n    | Constructor<RenderingEngine<unknown, unknown>>\n    | RenderingEngine<unknown, unknown>;\n\n  /**\n   * Flag indicating whether the rendering engine has been initialized.\n   */\n  protected initialized: boolean = false;\n\n  protected constructor(readonly flavour: string) {\n    RenderingEngine.register(this);\n    console.log(`decaf's ${flavour} rendering engine loaded`);\n  }\n\n  abstract getModal<C extends DecafComponent<Model>>(\n    component: Partial<C>,\n    ...args: any[]\n  ): Promise<IDecafModal>;\n\n  abstract getToast(options: DecafToastOptions): Promise<IDecafToast>;\n\n  abstract getSpinner(options: DecafSpinnerOptions): Promise<IDecafSpinner>;\n\n  abstract router(): IDecafRouter;\n\n  /**\n   * @description Initializes the rendering engine.\n   * @summary Abstract method to be implemented by subclasses for specific initialization logic.\n   *\n   * @param {...any[]} args - Any additional arguments needed for initialization.\n   * @returns {Promise<void>} A promise that resolves when initialization is complete.\n   *\n   * @abstract\n   */\n  abstract initialize(...args: any[]): Promise<void>;\n\n  /**\n   * @description Translates between model types and HTML input types.\n   * @summary Converts model data types to appropriate HTML input types and vice versa.\n   *\n   * @param {string} key - The key to translate.\n   * @param {boolean} [toView=true] - Direction of translation (true for model to view, false for view to model).\n   * @returns {string} The translated type.\n   */\n  translate(key: string, toView: boolean = true): string {\n    if (toView) {\n      switch (key) {\n        case ReservedModels.STRING.name.toLowerCase():\n          return HTML5InputTypes.TEXT;\n        case ReservedModels.NUMBER.name.toLowerCase():\n        case ReservedModels.BIGINT.name.toLowerCase():\n          return HTML5InputTypes.NUMBER;\n        case ReservedModels.BOOLEAN.name.toLowerCase():\n          return HTML5InputTypes.CHECKBOX;\n        case ReservedModels.DATE.name.toLowerCase():\n          return HTML5InputTypes.DATE;\n      }\n    } else {\n      switch (key) {\n        case HTML5InputTypes.SELECT:\n        case HTML5InputTypes.TEXT:\n        case HTML5InputTypes.EMAIL:\n        case HTML5InputTypes.COLOR:\n        case HTML5InputTypes.PASSWORD:\n        case HTML5InputTypes.TEL:\n        case HTML5InputTypes.URL:\n        case HTML5InputTypes.SEARCH:\n        case HTML5InputTypes.HIDDEN:\n        case HTML5InputTypes.TEXTAREA:\n        case HTML5InputTypes.RADIO:\n          return ReservedModels.STRING.name.toLowerCase();\n        case HTML5InputTypes.NUMBER:\n          return ReservedModels.NUMBER.name.toLowerCase();\n        case HTML5InputTypes.CHECKBOX:\n          return ReservedModels.BOOLEAN.name.toLowerCase();\n        case HTML5InputTypes.DATE:\n        case HTML5InputTypes.DATETIME_LOCAL:\n        case HTML5InputTypes.TIME:\n          return ReservedModels.DATE.name.toLowerCase();\n      }\n    }\n    return key;\n  }\n\n  /**\n   * @description Retrieves class decorator metadata for a model instance\n   * @summary Extracts UI-related class decorators from a model and returns them as an array\n   * This method collects metadata from various UI class decorators including @uimodel,\n   * @uilistmodel, @uihandlers, and @uilayout applied to the model class.\n   *\n   * @template M Type extending Model\n   * @param {M} model - The model instance to extract metadata from\n   * @returns {UIClassMetadata[]} Array of UI class metadata objects\n   *\n   * @private\n   */\n  private getClassDecoratorsMetadata<M extends Model>(\n    model: M\n  ): UIClassMetadata[] {\n    return [\n      Model.uiModelOf(model.constructor as Constructor<M>),\n      Model.uiListModelOf(model.constructor as Constructor<M>),\n      Model.uiHandlersFor(model.constructor as Constructor<M>),\n      Model.uiLayoutOf(model.constructor as Constructor<M>),\n    ].filter(Boolean) as UIClassMetadata[];\n  }\n\n  private sortChildrenByOrder(children: FieldDefinition<any>[] = []) {\n    return children.sort((a, b) => {\n      const aOrder = a.props?.order ?? 0;\n      const bOrder = b.props?.order ?? 0;\n      const weight = (v: number | string) =>\n        v === UIKeys.FIRST\n          ? 0\n          : typeof v === Primitives.NUMBER\n            ? 1\n            : v === UIKeys.LAST\n              ? //TODO: review this\n                children.length + children.indexOf(b)\n              : 1;\n\n      const aWeight = weight(aOrder);\n      const bWeight = weight(bOrder);\n      if (aWeight !== bWeight) {\n        return aWeight - bWeight;\n      }\n\n      if (\n        aWeight === 1 &&\n        typeof aOrder === Primitives.NUMBER &&\n        typeof bOrder === Primitives.NUMBER\n      ) {\n        return aOrder - bOrder;\n      }\n      return 0;\n    });\n  }\n\n  /**\n   * @description Checks if a validation key represents a custom validator (i.e., not a built-in validation or UI key).\n   * @summary Determines whether the provided key corresponds to a user-defined validator by excluding all built-in ValidationKeys and UIKeys.\n   *\n   * @param {string} key - The validation key to check.\n   * @returns {boolean} True if the key is a custom validator, false otherwise.\n   * @returns {boolean} True if the key is not a built-in validation key or UI key (i.e. is custom), false otherwise.\n   */\n  protected isCustomValidator(key: string): boolean {\n    return (\n      !Object.values(ValidationKeys).includes(\n        key as (typeof ValidationKeys)[keyof typeof ValidationKeys]\n      ) && !Object.values(UIKeys).includes(key)\n    );\n  }\n\n  /**\n   * @description Checks if a type is validatable by its nature.\n   * @summary Determines if a given UI key represents a type that is inherently validatable.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable, false otherwise.\n   */\n  protected isValidatableByType(key: string): boolean {\n    return Object.keys(ValidatableByType).includes(key);\n  }\n\n  /**\n   * @description Checks if a type is validatable by attribute.\n   * @summary Determines if a given UI key represents a validation that can be applied as an attribute.\n   *\n   * @param {string} key - The UI key to check.\n   * @returns {boolean} True if the type is validatable by attribute, false otherwise.\n   */\n  protected isValidatableByAttribute(key: string): boolean {\n    return Object.keys(ValidatableByAttribute).includes(key);\n  }\n\n  /**\n   * @description Converts validation metadata to an attribute value.\n   * @summary Transforms validation metadata into a value suitable for use as an HTML attribute.\n   *\n   * @param {string} key - The validation key.\n   * @param {ValidationMetadata} value - The validation metadata.\n   * @returns {string | number | boolean} The converted attribute value.\n   * @throws {Error} If the given key is not validatable by attribute.\n   */\n  protected toAttributeValue(\n    key: string,\n    value: ValidationMetadata\n  ): string | number | boolean {\n    if (!Object.keys(ValidatableByAttribute).includes(key))\n      throw new Error(\n        `Invalid attribute key \"${key}\". Expected one of: ${Object.keys(ValidatableByAttribute).join(\", \")}.`\n      );\n\n    return key === UIKeys.REQUIRED ? true : value[key];\n  }\n\n  /**\n   * @description Converts a model to a field definition.\n   * @summary Processes a model instance, extracting UI-related metadata and validation rules to create a field definition.\n   *\n   * @template M Type extending Model\n   * @template T Type referencing the specific Rendering engine field properties/inputs\n   * @param {M} model - The model instance to convert.\n   * @param {Record<string, unknown>} [globalProps={}] - Global properties to apply to all child elements.\n   * @param {boolean} [generateId=true] - Flag indicating whether to populate the rendererId property.\n   * @returns {FieldDefinition<T>} A field definition object representing the UI structure of the model.\n   * @throws {RenderingError} If no UI definitions are set for the model or if there are invalid decorators.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *  participant C as Client\n   *  participant RE as RenderingEngine\n   *  participant R as Reflection\n   *  participant M as Model\n   *  C->>RE: toFieldDefinition(model, globalProps)\n   *  RE->>R: getMetadata(UIKeys.UIMODEL, model.constructor)\n   *  R-->>RE: UIModelMetadata\n   *  RE->>R: getAllPropertyDecorators(model, UIKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata[]>\n   *  RE->>R: getAllPropertyDecorators(model, ValidationKeys.REFLECT)\n   *  R-->>RE: Record<string, DecoratorMetadata<ValidationMetadata>[]>\n   *  loop For each property\n   *    RE->>RE: Process UI decorators\n   *    RE->>RE: Apply validation rules\n   *  end\n   *  RE-->>C: FieldDefinition<T>\n   */\n  protected toFieldDefinition<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown> = {},\n    generateId: boolean = true\n  ): FieldDefinition<T> {\n    const { inheritProps, ...globalPropsWithoutInherits } = globalProps;\n    globalProps = globalPropsWithoutInherits;\n\n    const classDecorators = this.getClassDecoratorsMetadata<M>(model);\n\n    if (!classDecorators.length)\n      throw new RenderingError(\n        `No ui definitions set for model ${model.constructor.name}. Did you use @uimodel?`\n      );\n\n    const classDecorator = Object.assign(\n      {},\n      ...classDecorators,\n      inheritProps ? inheritProps : {} // override tag and properties when it is a component that should inherit properties from its parent.\n    );\n    const { tag, props, item, handlers } = classDecorator;\n\n    const uiDecorators = Model.uiPropertiesOf(\n      model.constructor as Constructor<M>\n    ) as (keyof M)[];\n\n    // const uiDecorators: Record<string, DecoratorMetadata[]> =\n    //   Reflection.getAllPropertyDecorators(model, UIKeys.REFLECT) as Record<\n    //     string,\n    //     DecoratorMetadata[]\n    //   >;\n    let children: FieldDefinition<Record<string, any>>[] | undefined;\n    let childProps: Record<string, any> = item?.props || {};\n    let mapper: Record<string, any> = {};\n    const getPath = (parent: string | undefined, prop: string) => {\n      return parent ? [parent, prop].join(\".\") : prop;\n    };\n\n    if (uiDecorators) {\n      const validationDecorators: Record<string, any> =\n        Metadata.get(\n          model.constructor as Constructor,\n          ValidationKeys.REFLECT\n        ) || {};\n      // const validationDecorators: Record<\n      //   string,\n      //   DecoratorMetadata<ValidationMetadata>[]\n      // > = Reflection.getAllPropertyDecorators(\n      //   model,\n      //   ValidationKeys.REFLECT\n      // ) as Record<string, DecoratorMetadata<ValidationMetadata>[]>;\n      for (const key of uiDecorators) {\n        const decs = Model.uiDecorationOf(\n          model.constructor as Constructor<M>,\n          key\n        );\n        let type: any;\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          type = Model.uiTypeOf(model.constructor as Constructor<M>, key);\n        } catch (e: unknown) {\n          if (!(e instanceof NotFoundError)) throw e;\n        }\n        // const types = Object.values(decs).filter(({ key }) =>\n        //   [UIKeys.PROP, UIKeys.ELEMENT, UIKeys.CHILD].includes(key)\n        // );\n        // if (!type)\n        //   throw new RenderingError(\n        //     `Only one type of decoration is allowed. Please choose between @uiprop, @uichild or @uielement`\n        //   );\n        const hasHideOnDecorator = Model.uiIsHidden(\n          model.constructor as Constructor<M>,\n          key\n        );\n        if (hasHideOnDecorator) {\n          const hasUiElementDecorator = Model.uiElementOf(\n            model.constructor as Constructor<M>,\n            key\n          );\n          if (!hasUiElementDecorator)\n            throw new RenderingError(\n              `@uielement no found in \"${key as string}\". It is required to use hiddenOn decorator.`\n            );\n        }\n        const sorted = Object.entries(decs)\n          .map(([k, v]) => ({\n            key: k,\n            props: v,\n          }))\n          .sort((a) => {\n            return [UIKeys.ELEMENT, UIKeys.CHILD].includes(a.key) ? -1 : 1;\n          });\n        sorted.forEach((dec) => {\n          if (!dec) throw new RenderingError(`No decorator found`);\n\n          switch (dec.key) {\n            case UIKeys.PROP: {\n              childProps[key as any] = dec.props as UIPropMetadata;\n              break;\n            }\n            case UIKeys.CHILD: {\n              const modelName =\n                (dec.props as UIModelMetadata)?.props?.name || (key as string);\n              try {\n                const isPropertyModel =\n                  Model.isModel(Model.build({}, modelName)) ||\n                  Model.isPropertyModel(model, modelName);\n                if (!isPropertyModel)\n                  throw new RenderingError(\n                    `Child \"${modelName as string}\" must be a model.`\n                  );\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n              } catch (e: unknown) {\n                throw new RenderingError(\n                  `Child \"${modelName as string}\" must be a model.`\n                );\n              }\n\n              let Clazz;\n              const submodel = (model as Record<string, any>)[\n                key as any\n              ] as Model;\n              const constructable =\n                typeof submodel === \"object\" &&\n                submodel !== null &&\n                !Array.isArray(submodel);\n              // create instance if undefined\n              if (!constructable) {\n                const clazzName = (\n                  (dec.props as any).props as Record<string, any>\n                )?.name as string;\n                Clazz = new (Model.get(clazzName) as ModelConstructor<Model>)();\n              }\n\n              children = children || [];\n              const childrenGlobalProps = Object.assign(\n                {},\n                globalProps || {},\n                { model: Clazz },\n                {\n                  inheritProps: dec.props as UIModelMetadata,\n                  childOf: getPath(\n                    globalProps?.childOf as string,\n                    key as string\n                  ),\n                }\n              );\n              const childDefinition = this.toFieldDefinition(\n                submodel || Clazz, // Must avoid undefined values — an instance is required to retrieve properties.\n                childrenGlobalProps,\n                false\n              );\n              const { inheritProps } = childrenGlobalProps;\n              if (inheritProps)\n                childDefinition.props = Object.assign(\n                  {},\n                  childDefinition.props,\n                  inheritProps.props || {}\n                );\n              children.push(\n                childDefinition as FieldDefinition<Record<string, any>>\n              );\n              break;\n            }\n            case UIKeys.UILISTPROP: {\n              mapper = mapper || {};\n              const decProps = dec.props as UIListPropMetadata;\n              if (decProps.name)\n                mapper[decProps.name] =\n                  typeof decProps?.props === \"object\" &&\n                  UIKeys.SEQUENCE in decProps.props\n                    ? decProps.props\n                    : key;\n\n              const props = Object.assign(\n                {},\n                classDecorator.props?.item || {},\n                item?.props || {},\n                decProps?.props || {},\n                globalProps\n              );\n              childProps = {\n                tag: item?.tag || props.render || \"\",\n                props: Object.assign({}, childProps?.props, { mapper }, props),\n              };\n\n              break;\n            }\n            case UIKeys.EVENTS:\n            case UIKeys.HIDDEN:\n            case UIKeys.HIDE_FOR:\n            case UIKeys.SHOW_FOR:\n            case UIKeys.PAGE:\n            case UIKeys.ORDER:\n            case UIKeys.UILAYOUTPROP:\n            case UIKeys.ELEMENT: {\n              children = children || [];\n              const uiProps: UIElementMetadata = dec.props as UIElementMetadata;\n              const visibilityProps =\n                dec.key === UIKeys.HIDE_FOR\n                  ? { hideFor: dec.props as string[] }\n                  : dec.key === UIKeys.SHOW_FOR\n                    ? { showFor: dec.props as string[] }\n                    : {};\n              const props = Object.assign(\n                {},\n                childProps?.props,\n                uiProps.props || {},\n                visibilityProps,\n                uiProps?.props?.name\n                  ? {\n                      path: getPath(\n                        globalProps?.childOf as string,\n                        uiProps.props!.name\n                      ),\n                      childOf: undefined, // The childOf prop is passed by globalProps when it is a nested prop\n                    }\n                  : {},\n                globalProps,\n                { name: uiProps.props?.name || key }\n              );\n\n              if (dec.key === UIKeys.ELEMENT) {\n                const childDefinition: FieldDefinition<Record<string, any>> = {\n                  tag: uiProps.tag || childProps?.tag || tag || \"\",\n                  props,\n                };\n                const validationDecs = validationDecorators[\n                  key as any\n                ] as ValidationMetadata[];\n                if (validationDecs) {\n                  for (const dec of Object.entries(validationDecs).map(\n                    ([k, v]) => ({ key: k, props: v })\n                  )) {\n                    if (this.isValidatableByAttribute(dec.key)) {\n                      childDefinition.props[this.translate(dec.key)] =\n                        this.toAttributeValue(dec.key, dec.props);\n                      continue;\n                    }\n                    if (this.isValidatableByType(dec.key)) {\n                      if (dec.key === HTML5InputTypes.DATE) {\n                        childDefinition.props[UIKeys.FORMAT] =\n                          dec.props.format || HTML5DateFormat;\n                      }\n                      childDefinition.props[UIKeys.TYPE] = dec.key;\n                      continue;\n                    }\n                    if (this.isCustomValidator(dec.key)) {\n                      props[UIKeys.SUB_TYPE] = dec.key;\n                      if (dec.props?.message) {\n                        props[UIKeys.VALIDATION_MESSAGE] = dec.props.message;\n                      }\n                    }\n                  }\n                }\n\n                if (!childDefinition.props[UIKeys.TYPE]) {\n                  const basicType = Metadata.type(\n                    model.constructor as Constructor,\n                    key as string\n                  ).name;\n                  childDefinition.props[UIKeys.TYPE] = this.translate(\n                    basicType.toLowerCase(),\n                    true\n                  );\n                }\n\n                childDefinition.props.value = formatByType(\n                  childDefinition.props[UIKeys.TYPE],\n                  model[key as keyof M],\n                  childDefinition.props[UIKeys.FORMAT]\n                );\n                children.push(childDefinition);\n              } else {\n              const child = children.find(\n                (c) =>\n                  c.props?.name === key ||\n                  ([UIKeys.UILAYOUTPROP, UIKeys.PAGE, UIKeys.EVENTS].includes(\n                    dec.key\n                  ) &&\n                    (c.props?.childOf === key ||\n                      c.props?.childOf?.endsWith(`.${key as string}`)))\n              );\n              if (child) {\n                  if (\n                    dec.key === UIKeys.HIDE_FOR ||\n                    dec.key === UIKeys.SHOW_FOR\n                  ) {\n                    child.props = Object.assign({}, child.props, visibilityProps);\n                  } else if (dec.key !== UIKeys.UILAYOUTPROP) {\n                    child.props = Object.assign({}, child.props, {\n                      [dec.key]: uiProps,\n                    });\n                  } else {\n                    const { row, col, props } = dec.props as any;\n                    child.props = Object.assign(\n                      {},\n                      props || {},\n                      child.props,\n                      row,\n                      col\n                    );\n                  }\n                }\n              }\n              break;\n            }\n            default:\n              throw new RenderingError(`Invalid key: ${dec.key}`);\n          }\n        });\n      }\n    }\n\n    globalProps = Object.assign({}, props, globalProps, {\n      handlers: handlers || {},\n    });\n\n    const currentNamespaces = new Set(\n      [\n        ...(Array.isArray(globalProps?.namespaces)\n          ? (globalProps.namespaces as string[])\n          : []),\n        ...(typeof globalProps?.namespace === \"string\"\n          ? [globalProps.namespace as string]\n          : []),\n      ].filter(Boolean)\n    );\n    const operation = globalProps?.operation;\n    children = this.sortChildrenByOrder(children).filter((item) => {\n      const hiddenOn = (item?.props?.hidden as CrudOperationKeys[]) || [];\n      if (\n        hiddenOn.length > 0 &&\n        hiddenOn.includes(operation as CrudOperationKeys)\n      ) {\n        return false;\n      }\n\n      const hideFor = (item?.props?.hideFor as string[]) || [];\n      const showFor = (item?.props?.showFor as string[]) || [];\n      if (\n        hideFor.length > 0 &&\n        [...currentNamespaces].some((namespace) => hideFor.includes(namespace))\n      ) {\n        return false;\n      }\n      if (\n        showFor.length > 0 &&\n        ![...currentNamespaces].some((namespace) => showFor.includes(namespace))\n      ) {\n        return false;\n      }\n      return true;\n    });\n    const result: FieldDefinition<T> = {\n      tag: tag,\n      item: childProps as UIListItemElementMetadata,\n      props: globalProps as T & FieldProperties & IPagedComponentProperties,\n      children: children?.length\n        ? (children as FieldDefinition<any>[])\n        : undefined,\n    };\n\n    if (generateId) result.rendererId = generateUIModelID(model);\n    return result;\n  }\n\n  /**\n   * @description Renders a model with global properties and additional arguments.\n   * @summary Abstract method to be implemented by subclasses to define specific rendering behavior.\n   *\n   * @template M Type extending Model\n   * @template R Rendering engine implementation specific output type\n   * @param {M} model - The model to be rendered.\n   * @param {Record<string, unknown>} globalProps - Global properties to be applied to all elements during rendering.\n   * @param {...any[]} args - Additional arguments that may be required for specific rendering implementations.\n   * @returns {R} The rendered result, type depends on the specific implementation.\n   *\n   * @abstract\n   */\n  abstract render<M extends Model>(\n    model: M,\n    globalProps: Record<string, unknown>,\n    ...args: any[]\n  ): R;\n\n  /**\n   * @description Registers a rendering engine instance.\n   * @summary Adds a rendering engine to the static cache and sets it as the current engine.\n   *\n   * @param {RenderingEngine<unknown, unknown>} engine - The rendering engine to register.\n   * @throws {InternalError} If an engine with the same flavor already exists.\n   *\n   * @static\n   */\n  static register(engine: RenderingEngine<unknown, unknown>) {\n    if (engine.flavour in this.cache)\n      throw new InternalError(\n        `Rendering engine under ${engine.flavour} already exists`\n      );\n    this.cache[engine.flavour] = engine;\n    this.current = engine;\n  }\n\n  /**\n   * @description Retrieves or initializes a rendering engine.\n   * @summary Gets an existing engine instance or creates and initializes a new one if given a constructor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {Constructor<RenderingEngine<O>> | RenderingEngine<O>} obj - The engine instance or constructor.\n   * @returns {RenderingEngine<O>} The initialized rendering engine.\n   *\n   * @private\n   * @static\n   */\n  private static getOrBoot<O>(\n    obj: Constructor<RenderingEngine<O>> | RenderingEngine<O>\n  ): RenderingEngine<O> {\n    if (obj instanceof RenderingEngine) return obj as RenderingEngine<O>;\n    const engine: RenderingEngine<O> = new obj();\n    engine.initialize(); // make the booting async. use the initialized flag to control it\n    return engine as RenderingEngine<O>;\n  }\n\n  /**\n   * @description Retrieves a rendering engine by flavor.\n   * @summary Gets the current rendering engine or a specific one by flavor.\n   *\n   * @template O The type of the rendering engine output\n   * @param {string} [flavour] - The flavor of the rendering engine to retrieve.\n   * @returns {RenderingEngine<O>} The requested rendering engine.\n   * @throws {InternalError} If the requested flavor does not exist.\n   *\n   * @static\n   */\n  static get<O>(flavour?: string): RenderingEngine<O> {\n    if (!flavour)\n      return this.getOrBoot<O>(\n        this.current as Constructor<RenderingEngine<O>> | RenderingEngine<O>\n      );\n    if (!(flavour in this.cache))\n      throw new InternalError(\n        `Rendering engine under ${flavour} does not exist`\n      );\n    return this.getOrBoot<O>(\n      this.cache[flavour] as\n        | Constructor<RenderingEngine<O>>\n        | RenderingEngine<O>\n    );\n  }\n\n  /**\n   * @description Renders a model using the appropriate rendering engine.\n   * @summary Determines the correct rendering engine for a model and invokes its render method.\n   *\n   * @template M Type extending Model\n   * @param {M} model - The model to render.\n   * @param {...any[]} args - Additional arguments to pass to the render method.\n   * @returns {any} The result of the rendering process.\n   * @throws {InternalError} If no registered model is found.\n   *\n   * @static\n   */\n  static render<M extends Model>(model: M, ...args: any[]): any {\n    const constructor =\n      Model.get(model.constructor.name) || Model.fromObject(model);\n    if (!constructor) throw new InternalError(\"No model registered found\");\n    const flavour = Model.renderedBy(model.constructor as Constructor<M>);\n\n    // @ts-expect-error for the var args type check\n    return RenderingEngine.get(flavour).render(model, ...args);\n  }\n}\n//\n// Decoration.for(DBKeys.ID)\n//   .extend({\n//     decorator: function pk(options: { generated: boolean }) {\n//       return function innerPk(target: object, propertyKey?: any) {\n//         if (options.generated)\n//           hideOn(OperationKeys.CREATE, OperationKeys.UPDATE)(\n//             target,\n//             propertyKey\n//           );\n//       };\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(DBKeys.TIMESTAMP)\n//   .extend({\n//     decorator: function timestamp(ops: OperationKeys[]) {\n//       return hideOn(...(ops as any[]));\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(DBKeys.COMPOSED)\n//   .extend({\n//     decorator: function composed() {\n//       return hideOn(OperationKeys.CREATE, OperationKeys.UPDATE);\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(\"createdBy\")\n//   .extend({\n//     decorator: function createdBy() {\n//       return hideOn(OperationKeys.CREATE, OperationKeys.UPDATE);\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(\"updatedBy\")\n//   .extend({\n//     decorator: function createdBy() {\n//       return hideOn(OperationKeys.CREATE, OperationKeys.UPDATE);\n//     },\n//   })\n//   .apply();\n","import { UIKeys } from \"./constants\";\nimport { propMetadata } from \"@decaf-ts/decoration\";\nimport {\n  CrudOperationKeys,\n  UIElementMetadata,\n  UIEventHandler,\n  UIEventName,\n  UIFunctionLike,\n  UILayoutCol,\n  UILayoutPropMetadata,\n  UIListPropMetadata,\n  UIPropMetadata,\n} from \"./types\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { getUIAttributeKey } from \"./utils\";\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 function hideOn(object: any, propertyKey?: any) {\n    return propMetadata(\n      getUIAttributeKey(propertyKey, UIKeys.HIDDEN),\n      operations\n    )(object, propertyKey);\n  };\n}\n\n/**\n * @description Decorator that hides a property for specific namespaces.\n * @summary Controls property visibility based on namespace membership.\n */\nexport function hideFor(...namespaces: string[]) {\n  return function hideFor(object: any, propertyKey?: any) {\n    return propMetadata(\n      getUIAttributeKey(propertyKey, UIKeys.HIDE_FOR),\n      namespaces\n    )(object, propertyKey);\n  };\n}\n\n/**\n * @description Decorator that shows a property only for specific namespaces.\n * @summary Namespace-aware counterpart to `hideFor`.\n */\nexport function showFor(...namespaces: string[]) {\n  return function showFor(object: any, propertyKey?: any) {\n    return propMetadata(\n      getUIAttributeKey(propertyKey, UIKeys.SHOW_FOR),\n      namespaces\n    )(object, propertyKey);\n  };\n}\n\n/**\n * @description Decorator that renders a property only when the namespace matches.\n * @summary Convenience alias for namespace-scoped visibility control.\n */\nexport function renderIf(...namespaces: string[]) {\n  return showFor(...namespaces);\n}\n\n/**\n * @description Decorator that sets the order of a UI element\n * @summary Specifies the rendering order for UI components\n * This decorator applies metadata to the property or class, indicating its order in the UI rendering sequence.\n *\n * @param {number} [order=1] The order value for the UI element (default is 1)\n * @return {Function} A property or class decorator function\n *\n * @function uiorder\n * @category Property Decorators\n *\n * @example\n * // Set order for a field\n * @uiorder(2)\n * fieldName: string;\n *\n * // Set order for a class\n * @uiorder(1)\n * class UserProfile { ... }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uiorder\n *   participant property\n *   System->>uiorder:do(property)\n *   uiorder->>property: sets order metadata\n *   uiorder->>System: returns decorated property\n */\nexport function uiorder(\n  order: number | typeof UIKeys.FIRST | typeof UIKeys.LAST = UIKeys.FIRST\n) {\n  return function uiorder(object: any, propertyKey?: any) {\n    return propMetadata(getUIAttributeKey(propertyKey, UIKeys.ORDER), order)(\n      object,\n      propertyKey\n    );\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 | Record<string, any>,\n  props?: Record<string, any>,\n  serialize: boolean = false\n) {\n  return (original: any, propertyKey?: any) => {\n    if (typeof tag === \"object\") {\n      props = tag;\n      tag = \"\";\n    }\n    const metadata: UIElementMetadata = {\n      tag: tag as string,\n      serialize: serialize,\n      props: Object.assign({}, props || {}, {\n        name: propertyKey,\n      }),\n    };\n\n    return propMetadata(\n      getUIAttributeKey(propertyKey, UIKeys.ELEMENT),\n      metadata\n    )(original, propertyKey);\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?: any) => {\n    const metadata: UIPropMetadata = {\n      name: propName || propertyKey,\n      stringify: stringify,\n    };\n    propMetadata(getUIAttributeKey(propertyKey, UIKeys.PROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that maps a nested model property to a UI component property.\n * @summary Defines how a parent component should render the child model when nested.\n *\n * This decorator is used to decorate properties that are nested models.\n * When applied, it allows overriding the default tag of the child model with the provided one,\n * enabling different rendering behavior when the model acts as a child (nested)\n * compared to when it is rendered as the parent model.\n *\n * It requires the class to be decorated with `@uimodel`.\n *\n * @param {string} clazz The model class name to pass to the component (defaults to the property key).\n * @param {string} tag The HTML element or component tag name to override the UI tag of the nested model\n * @param {Record<string, any>} [props] Additional properties to pass to the element\n * @param {boolean} [serialize=false] Whether the property should be serialized\n * @return {Function} A property decorator function.\n *\n * @function uichild\n * @category Property Decorators\n *\n * @example\n * // Map a nested model to a component property with a different tag when nested\n * @uimodel('address-component')\n * class Address {\n *   @attribute()\n *   street: string;\n *\n *   @attribute()\n *   city: string;\n * }\n *\n * @uimodel('user-profile')\n * class UserProfile {\n *   @attribute()\n *   @uichild(Address.name, 'address-child-component')\n *   address: Address;\n * }\n *\n * // In this example, the Address model has the default tag 'address-component' when rendered as a root component,\n * // but when used inside UserProfile, it is rendered with the overridden tag 'address-child-component'\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uichild\n *   participant RenderingEngine\n *   participant Component\n *   Model->>uichild: Apply to property\n *   uichild->>Model: Add child metadata\n *   RenderingEngine->>Model: Get child metadata\n *   Model->>RenderingEngine: Return prop name, stringify flag, and child tag override\n *   RenderingEngine->>Component: Pass property with specified name and render with overridden tag if nested\n */\n\nexport function uichild(\n  clazz: string,\n  tag: string,\n  props: Record<string, any> = {},\n  isArray: boolean = false,\n  serialize: boolean = false\n) {\n  return (target: any, propertyKey?: any) => {\n    const metadata: UIElementMetadata = {\n      tag: tag,\n      serialize: serialize,\n      props: Object.assign(\n        {},\n        props || {},\n        {\n          name: clazz || propertyKey,\n        },\n        isArray\n          ? { customTypes: [Array.name], multiple: true }\n          : { multiple: props?.multiple || false }\n      ),\n    };\n\n    propMetadata(getUIAttributeKey(propertyKey, 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 @uilistmodel.\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 * @uilistmodel('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 @uilistmodel\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?: any) => {\n    const metadata: Partial<UIListPropMetadata> = {\n      name: propName || propertyKey,\n      props: props || {},\n    };\n    propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILISTPROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that positions a property in a specific grid layout position\n * @summary Specifies the column and row position for a property in a UI layout grid\n * This decorator allows you to define the specific position of a property within\n * a grid-based layout system. It specifies which column and row the property\n * should occupy when rendered in the UI.\n *\n * @param {number} col The column position in the grid layout\n * @param {number} [row=1] The row position in the grid layout (defaults to 1)\n * @param {Record<string, any>} [props={}] Additional properties to pass to the layout item\n * @return {Function} A property decorator function\n *\n * @function uilayoutprop\n * @category Property Decorators\n *\n * @example\n * // Position properties in a grid layout\n * @uilayout('user-form', 2, 3) // 2 columns, 3 rows\n * @model()\n * class UserForm {\n *   @attribute()\n *   @uilayoutprop(1, 1) // One column, first row\n *   firstName: string;\n *\n *   @attribute()\n *   @uilayoutprop(2, 1) // One column, first row\n *   lastName: string;\n *\n *   @attribute()\n *   @uilayoutprop(1, 2) // One column, second row\n *   email: string;\n *\n *   @attribute()\n *   @uilayoutprop(2, 3) // All columns, third row\n *   bio: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uilayoutprop\n *   participant RenderingEngine\n *   participant LayoutContainer\n *   Model->>uilayoutprop: Apply to property\n *   uilayoutprop->>Model: Add layout item metadata\n *   RenderingEngine->>Model: Get layout item metadata\n *   Model->>RenderingEngine: Return column, row, and props\n *   RenderingEngine->>LayoutContainer: Position element at grid coordinates\n *   LayoutContainer->>RenderingEngine: Return positioned element\n */\nexport function uilayoutprop(col: UILayoutCol = 1, row: number = 1) {\n  return (target: any, propertyKey?: any) => {\n    const metadata: UILayoutPropMetadata = {\n      name: propertyKey,\n      // col,\n      // row,\n      props: Object.assign({}, { row, col }),\n    };\n    propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILAYOUTPROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n\n/**\n * @description Decorator that assigns a property to a specific page in multi-page forms\n * @summary Specifies which page a property should appear on in paginated UI layouts\n * This decorator applies metadata to the property, indicating which page number it belongs to\n * in a multi-page form or wizard. Properties with the same page number are grouped together\n * and rendered on the same page. This is typically used in conjunction with @uisteppedmodel to\n * organize large forms into manageable sections.\n *\n * @param {number} [page=1] The page number where the property should appear (default is 1)\n * @return {Function} A property decorator function\n *\n * @function uipageprop\n * @category Property Decorators\n *\n * @example\n * // Create a multi-step registration form with page-based layout\n * @uisteppedmodel('registration-form', 2, true)\n * @model()\n * class RegistrationForm {\n *   // Page 1: Personal Information\n *   @attribute()\n *   @uipageprop(1)\n *   firstName: string;\n *\n *   @attribute()\n *   @uipageprop(1)\n *   lastName: string;\n *\n *   @attribute()\n *   @uipageprop(1)\n *   dateOfBirth: Date;\n *\n *   // Page 2: Contact Information\n *   @attribute()\n *   @uipageprop(2)\n *   email: string;\n *\n *   @attribute()\n *   @uipageprop(2)\n *   phone: string;\n *\n *   // Page 3: Confirmation\n *   @attribute()\n *   @uipageprop(3)\n *   acceptTerms: boolean;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uipageprop\n *   participant RenderingEngine\n *   participant PaginationController\n *   participant UI\n *   Model->>uipageprop: Apply to property\n *   uipageprop->>Model: Add page metadata\n *   RenderingEngine->>Model: Get page metadata\n *   Model->>RenderingEngine: Return page number\n *   RenderingEngine->>PaginationController: Group properties by page\n *   PaginationController->>UI: Render current page properties\n */\nexport function uipageprop(page: number = 1) {\n  return function uipageprop(original: any, propertyKey?: any) {\n    return propMetadata(getUIAttributeKey(propertyKey, UIKeys.PAGE), page)(\n      original,\n      propertyKey\n    );\n  };\n}\n\n/**\n * A decorator factory that binds a UI event to a specified handler function.\n * This is used to attach event handlers to specific lifecycle events of a `DecafComponent`,\n * such as `render` | `initialize` | `handleClick` | `refresh`\n *\n * @param event - The name of the lifecycle event to bind the handler to.\n *                Must be one of the keys in `Pick<DecafComponent, 'render' | 'initialize'>`.\n * @param handler - The function to be executed when the specified event occurs.\n *\n * @returns A decorator function that applies the event-handler binding to the target object.\n *\n * @example\n * ```typescript\n * class MyComponent {\n *   @uion('render', () => console.log('Rendering...'))\n *   someProperty: string;\n * }\n * ```\n */\nexport function uion(\n  event: UIEventName,\n  handler: UIEventHandler\n): (original: object, propertyKey?: string) => void;\nexport function uion(\n  events: Record<string, UIEventHandler>\n): (original: object, propertyKey?: string) => void;\nexport function uion(\n  event: UIEventName | Record<string, UIEventHandler>,\n  handler?: UIEventHandler\n) {\n  return function uion(original: object, propertyKey?: string) {\n    propMetadata(getUIAttributeKey(propertyKey as string, UIKeys.EVENTS), {\n      ...(typeof event === \"object\" ? event : { [event]: handler }),\n    })(original, propertyKey);\n  };\n}\n\n/**\n * A decorator function that associates a UI click handler with the 'handleClick' event.\n *\n * @param handler - A function that conforms to the `UIEventHandler` type, which will be executed\n *                  when the 'handleClick' event is triggered.\n * @returns A decorated function that binds the handler to the 'handleClick' event.\n */\nexport function uionclick(handler: UIEventHandler) {\n  return uion(\"handleClick\", handler);\n}\n\n/**\n * A decorator function that associates a UI rendering handler with the 'render' event.\n *\n * @param handler - A function that conforms to the `UIEventHandler ` type, which will be executed\n *                  when the 'render' event is triggered.\n * @returns A decorated function that binds the handler to the 'render' event.\n */\nexport function uionrender(handler: UIEventHandler) {\n  return uion(\"render\", handler);\n}\n\n/**\n * @description Decorator that marks a property as a column in a UI table\n * @summary Controls column ordering and optional value parsing for table props\n * Use this decorator to register list properties as table columns, define the\n * sequence in which they appear, and optionally provide a parser that formats\n * the value before rendering.\n *\n * @param {number} sequence The display order for the column (lower means first)\n * @param {UIFunctionLike} [valueParserFn] Optional formatter executed per cell\n * @return {Function} A property decorator function\n *\n * @function uitablecol\n * @category Property Decorators\n *\n * @example\n * class Order {\n *   @attribute()\n *   @uitablecol(1)\n *   orderNumber: string;\n *\n *   @attribute()\n *   @uitablecol(2, (value) => `$${value?.toFixed(2)}`)\n *   total: number;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant uitablecol\n *   participant RenderingEngine\n *   participant Table\n *   Model->>uitablecol: Apply to property\n *   uitablecol->>Model: Store column metadata\n *   RenderingEngine->>Model: Retrieve column props\n *   Model->>RenderingEngine: Return order and parser\n *   RenderingEngine->>Table: Render column in sequence\n */\nexport function uitablecol(\n  sequence: number | typeof UIKeys.FIRST | typeof UIKeys.LAST = UIKeys.LAST,\n  valueParserFn?: UIFunctionLike\n) {\n  return (target: any, propertyKey?: any) => {\n    const metadata: Partial<UIListPropMetadata> = {\n      name: propertyKey,\n      props: {\n        sequence,\n        ...(!valueParserFn ? {} : { valueParserFn }),\n      },\n    };\n    propMetadata(getUIAttributeKey(propertyKey, UIKeys.UILISTPROP), metadata)(\n      target,\n      propertyKey\n    );\n  };\n}\n","import { Validator } from \"@decaf-ts/decorator-validation\";\nimport { DecafTranslateService } from \"./DecafTranslateService\";\n\nexport abstract class UIValidator extends Validator {\n  static translateService: DecafTranslateService;\n\n  override getMessage(message: string, ...args: any[]): string {\n    if (UIValidator.translateService)\n      return UIValidator.translateService.translate(message, ...args);\n    return super.getMessage(message, ...args);\n  }\n}\n","import { LoggedClass } from \"@decaf-ts/logging\";\nimport {\n  CrudOperationKeys,\n  UIEventHandler,\n  UIEventProperty,\n  UIFunctionLike,\n} from \"./types\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { IRepository, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { DecafEventHandler } from \"./DecafEventHandler\";\nimport { DecafTranslateService } from \"./DecafTranslateService\";\nimport { isClassConstructor } from \"./utils\";\n\ntype PrimaryKeyType = string | number | bigint;\n\n/**\n * @description Base class for all Decaf UI components\n * @summary Base class for all Decaf UI components, providing common state management,\n * logging, localization, navigation hooks, CRUD context metadata, and\n * repository integration used by higher-level decorators and renderers.\n */\nexport abstract class DecafComponent<M extends Model> extends LoggedClass {\n  /**\n   * @description Data model or model name for component operations.\n   * @summary The data model that this component will use for CRUD operations. This can be provided\n   * as a Model instance, a model constructor, or a string representing the model's registered name.\n   * When set, this property provides the component with access to the model's schema, validation rules,\n   * and metadata needed for rendering and data operations.\n   */\n  model!: M | Model | string | undefined;\n\n  /**\n   * @description Primary key value of the current model instance.\n   * @summary Specifies the primary key value for the current model record being displayed or\n   * manipulated by the component. This identifier is used for CRUD operations that target\n   * specific records, such as read, update, and delete operations. The value corresponds to\n   * the field designated as the primary key in the model definition.\n   */\n  modelId?: PrimaryKeyType | PrimaryKeyType[];\n\n  /**\n   * @description Pre-built filtering expression applied to repository queries.\n   * @summary Supply a custom `AttributeOption` to control how records are constrained. When omitted,\n   * the directive derives a condition from `filterBy` or `pk`, comparing it against `modelId`.\n   */\n  filter!: any;\n\n  /**\n   * @description Model field used when generating the default condition.\n   * @summary Indicates which key should be compared to `modelId` when `filter` is not provided.\n   * Defaults to the configured primary key so overrides are only needed for custom lookups.\n   */\n  filterBy!: string;\n\n  /**\n   * @description The CRUD operation type to be performed on the model.\n   * @summary Specifies which operation (Create, Read, Update, Delete) this component instance\n   * should perform. This determines the UI behavior, form configuration, and available actions.\n   * The operation affects form validation, field availability, and the specific repository\n   * method called during data submission.\n   *\n   * @type {OperationKeys}\n   */\n  operation?: OperationKeys;\n\n  /**\n   * @description Router instance for programmatic navigation.\n   * @summary Injected Router service used for programmatic navigation between routes\n   * in the application. This service enables navigation to different views and operations,\n   * handles route parameters, and manages the browser's navigation history.\n   * @protected\n   */\n  router?: any;\n\n  /**\n   * @description Name identifier for the component instance.\n   * @summary Provides a string identifier that can be used to name or label the component\n   * instance. This name can be used for debugging purposes, logging, or to identify specific\n   * component instances within a larger application structure. It serves as a human-readable\n   * identifier that helps distinguish between multiple instances of the same component type.\n   */\n  name!: string;\n\n  /**\n   * @description Parent component identifier for hierarchical component relationships.\n   * @summary Specifies the identifier of the parent component in a hierarchical component structure.\n   * This property establishes a parent-child relationship between components, allowing for\n   * proper nesting and organization of components within a layout. It can be used to track\n   * component dependencies and establish component hierarchies for rendering and event propagation.\n   */\n  childOf!: string | undefined;\n\n  /**\n   * @description Unique identifier for the component instance.\n   * @summary A unique identifier automatically generated for each component instance.\n   * This UID is used for DOM element identification, component tracking, and debugging purposes.\n   * By default, it generates a random 16-character value, but it can be explicitly set via input.\n   */\n  uid?: PrimaryKeyType;\n\n  /**\n   * @description Primary key field name for the data model.\n   * @summary Specifies which field in the model should be used as the primary key.\n   * This is typically used for identifying unique records in operations like update and delete.\n   * If not explicitly set, it defaults to the repository's configured primary key or 'id'.\n1   */\n  pk!: string;\n\n  /**\n   * @description Translation service for application internationalization.\n   * @summary Injected service that provides translation capabilities for UI text.\n   * Used to translate button labels, validation messages, and other text content based\n   * on the current locale setting, enabling multilingual support throughout the application.\n   * @protected\n   */\n  translateService!: DecafTranslateService;\n\n  /**\n   * @description Angular change detection service for manual change detection control.\n   * @summary Injected service that provides manual control over change detection cycles.\n   * This is essential for ensuring that programmatic DOM changes (like setting accordion\n   * attributes) are properly reflected in the component's state and trigger appropriate\n   * view updates when modifications occur outside the normal Angular change detection flow.\n   * @protected\n   */\n  protected changeDetectorRef?: any;\n\n  /**\n   * @description Controls field visibility based on CRUD operations.\n   * @summary Can be a boolean or an array of operation keys where the field should be hidden.\n   */\n  hidden?: boolean | CrudOperationKeys[];\n\n  /**\n   * @description Label for the file upload field.\n   * @summary Provides a user-friendly label for the file upload input.\n   */\n  label?: string;\n\n  /**\n   * @description Whether the field is read-only.\n   */\n  readonly?: boolean;\n\n  /**\n   * @description Flag to enable or disable dark mode support for the component.\n   * @summary When enabled, the component will automatically detect the system's dark mode\n   * preference using the media service and apply appropriate styling classes. This flag\n   * controls whether the component should respond to dark mode changes and apply the\n   * dark palette class to its DOM element. By default, dark mode support is disabled.\n   * @protected\n   */\n  protected enableDarkMode: boolean = true;\n\n  /**\n   * @description Flag to enable or disable dark mode support for the component.\n   * @summary When enabled, the component will automatically detect the system's dark mode\n   * preference using the media service and apply appropriate styling classes. This flag\n   * controls whether the component should respond to dark mode changes and apply the\n   * dark palette class to its DOM element. By default, dark mode support is disabled.\n   * @protected\n   */\n  protected isDarkMode: boolean = false;\n\n  /**\n   * @description Current locale identifier for component internationalization.\n   * @summary Specifies the locale code (e.g., 'en-US', 'pt-BR') used for translating UI text\n   * and formatting data according to regional conventions. This property can be set to override\n   * the default application locale for this specific component instance, enabling per-component\n   * localization when needed.\n   */\n  locale?: string;\n\n  /**\n   * @description Configuration for list item rendering behavior.\n   * @summary Defines how list items should be rendered in the component.\n   * This property holds a configuration object that specifies the tag name\n   * and other properties needed to render list items correctly. The tag property\n   * identifies which component should be used to render each item in a list.\n   * Additional properties can be included to customize the rendering behavior.\n   */\n  item: Record<string, unknown> = { tag: \"\" };\n\n  /**\n   * @description Dynamic properties configuration for runtime customization.\n   * @summary Contains key-value pairs of dynamic properties that can be applied to the component\n   * at runtime. This flexible configuration object allows for dynamic property assignment without\n   * requiring explicit input bindings for every possible configuration option. Properties from\n   * this object are parsed and applied to the component instance through the parseProps method,\n   * enabling customizable component behavior based on external configuration.\n   */\n  props: Record<string, unknown> = {};\n\n  /**\n   * @description Base route path for component navigation.\n   * @summary Defines the base route path used for navigation actions related to this component.\n   * This is often used as a prefix for constructing navigation URLs when transitioning between\n   * different operations or views. The route helps establish the component's position in the\n   * application's routing hierarchy.\n   */\n  route?: string = \"\";\n\n  /**\n   * @description Controls whether borders are displayed around the component.\n   * @summary Boolean flag that determines if the component should be visually outlined with borders.\n   * When true, borders are shown to visually separate the component from surrounding content.\n   */\n  borders: boolean = false;\n\n  /**\n   * @description Component name identifier for logging and localization contexts.\n   * @summary Stores the component's name which is used as a key for logging contexts\n   * and as a base for locale resolution.\n   * @protected\n   */\n  protected componentName?: string;\n\n  /**\n   * @description Root key for component locale context resolution.\n   * @summary Defines the base key used to resolve localization contexts for this component.\n   * If not explicitly provided, it defaults to the component's name. This key is used to\n   * load appropriate translation resources and locale-specific configurations.\n   * @protected\n   */\n  protected localeRoot?: string;\n\n  /**\n   * @description Current value of the component.\n   * @summary Can be a string, number, date, or array of string or objects.\n   */\n  value?: any;\n\n  /**\n   * @description Reference to CRUD operation constants for template usage.\n   * @summary Exposes the OperationKeys enum to the component template, enabling\n   * conditional rendering and behavior based on operation types. This protected\n   * readonly property ensures that template logic can access operation constants\n   * while maintaining encapsulation and preventing accidental modification.\n   * @protected\n   * @readonly\n   */\n  protected readonly OperationKeys = OperationKeys;\n\n  /**\n   * @description Angular Location service.\n   * @summary Injected service that provides direct access to the browser's URL and history.\n   * Unlike the Router, Location allows for low-level manipulation of the browser's history stack\n   * and URL path, such as programmatically navigating back or forward, or updating the URL without\n   * triggering a route change. This is useful for scenarios where you need to interact with the\n   * browser history or URL outside of Angular's routing system, such as closing modals, handling\n   * popstate events, or supporting custom navigation logic.\n   *\n   */\n  location!: any;\n\n  /**\n   * @description Repository instance for data layer operations.\n   * @summary Provides a connection to the data layer for retrieving and manipulating data.\n   * This is an instance of the DecafRepository class, initialized lazily in the repository getter.\n   * The repository is used to perform CRUD (Create, Read, Update, Delete) operations on the\n   * data model and provides methods for querying and filtering data based on specific criteria.\n   *\n   * @protected\n   */\n  protected _repository?: IRepository<M>;\n\n  /**\n   * @description Initialization status flag for the component.\n   * @summary Tracks whether the component has completed its initialization process.\n   * This flag is used to prevent duplicate initialization and to determine if\n   * certain operations that require initialization can be performed.\n   * @default false\n   */\n  protected initialized: boolean = false;\n\n  protected events: UIEventProperty = {};\n\n  protected handlers: UIEventProperty = {};\n\n  protected constructor() {\n    super();\n  }\n\n  get repository(): IRepository<M> {\n    return this._repository as IRepository<M>;\n  }\n\n  set repository(repository: IRepository<M>) {\n    this._repository = repository;\n  }\n\n  async render(...args: unknown[]): Promise<any> {\n    this.log\n      .for(this.render)\n      .info(`render for ${this.componentName} with ${JSON.stringify(args)}`);\n  }\n\n  async refresh(...args: unknown[]): Promise<any> {\n    this.log.for(this.refresh).info(`Refresh called with args: ${args}`);\n  }\n\n  /**\n   * Asynchronously initializes the component with the provided arguments.\n   * This method sets the `initialized` property to `true` once the initialization is complete.\n   *\n   * @param args - A variable number of arguments of unknown types that can be used for initialization.\n   * @returns A promise that resolves when the initialization is complete.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async initialize(...args: unknown[]): Promise<any> {\n    this.initialized = true;\n  }\n\n  /**\n   * Translates content based on the provided arguments.\n   * Logs the translation request with the component name and arguments.\n   *\n   * @param args - A variable number of arguments used for translation.\n   * @returns A promise that resolves with the translation result.\n   */\n  async translate(...args: unknown[]): Promise<any> {\n    this.log\n      .for(this.translate)\n      .info(`translate for ${this.componentName} with ${JSON.stringify(args)}`);\n  }\n\n  async preview(...args: unknown[]): Promise<void> {\n    this.log.for(this.preview).debug(`Preview called with args: ${args}`);\n  }\n\n  // async process(...args: unknown[]): Promise<any> {\n  //   this.log.for(this.process).debug(`Process called with args: ${args}`);\n  // }\n\n  // async batchOperation(...args: unknown[]): Promise<any> {\n  //   this.log\n  //     .for(this.batchOperation)\n  //     .debug(`BatchOperation called with args: ${args}`);\n  // }\n\n  /**\n   * Submits data or performs an action associated with the component.\n   *\n   * @param args - A variable number of arguments of any type to be passed to the submit operation.\n   * @returns A promise that resolves with the result of the submit operation.\n   */\n  async submit(...args: unknown[]): Promise<any> {\n    this.log\n      .for(this.submit)\n      .info(`submit for ${this.componentName} with ${JSON.stringify(args)}`);\n  }\n\n  /**\n   * @description Normalizes handler definitions into executable functions.\n   * @summary Iterates through a handlers map and ensures each entry is stored as a callable\n   * function on the component. Plain functions are stored directly, while handler classes are\n   * instantiated so their `handle` method (or a keyed override) becomes the registered handler.\n   * This allows decorators to accept either inline functions or handler classes transparently.\n   * @template T Extends `DecafEventHandler` to constrain handler class types.\n   * @param handlers - Dictionary of handler names mapped to functions or handler constructors.\n   * @param instance - Optional target handler instance; defaults to the current component.\n   */\n  protected parseHandlers<T extends DecafEventHandler>(\n    handlers: UIEventProperty,\n    instance: T\n  ): UIEventProperty {\n    const result: UIEventProperty = {};\n    Object.entries(handlers).forEach(([key, fn]) => {\n      if (isClassConstructor<DecafEventHandler>(fn)) {\n        const clazz = new fn() as DecafEventHandler;\n        const event =\n          key in clazz ? clazz[key as keyof DecafEventHandler] : clazz.handle;\n        result[key] = event;\n        instance.handlers[key] = event;\n      } else {\n        result[key] = fn;\n        instance.handlers[key] = fn;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * @description Registers event callbacks on the component instance.\n   * @summary Processes an events map produced by decorators where each value can be a factory\n   * returning a function or a component constructor. When a constructor is returned, the method\n   * matching the event key is instantiated and stored; otherwise the produced function is\n   * assigned directly. This enables flexible event binding definitions for derived components.\n   * @template T Extends `DecafComponent<Model>` to scope acceptable event owners.\n   * @param events - Dictionary of event names mapped to function factories or component constructors.\n   * @param instance - Optional component instance to receive the events; defaults to `this`.\n   */\n  protected parseEvents<T extends DecafComponent<Model>>(\n    events: UIEventProperty,\n    instance: T\n  ): UIEventProperty {\n    const result: UIEventProperty = {};\n    Object.entries(events).forEach(([key, fn]) => {\n      const name = key as string;\n      const evt = (fn as UIFunctionLike)();\n      if (isClassConstructor<T>(evt)) {\n        const fn = new evt()[key as keyof T] as UIEventHandler;\n        if (fn) {\n          result[name] = fn;\n          instance.events[name] = fn;\n        }\n      } else {\n        result[name] = fn;\n        instance.events[name] = fn;\n      }\n    });\n    return result;\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { DecafComponent } from \"./DecafComponent\";\n\n/**\n * @description Class representing an event handler\n * @summary Defines the structure for handling events in the UI decorators system\n * This class provides a foundation for managing and processing events that occur\n * within the UI components generated by the decorators.\n * @class EventHandler\n * @memberOf module:ui-decorators/ui\n */\nexport class DecafEventHandler extends DecafComponent<Model> {\n  /**\n   * @description Creates an instance of DecafEventHandler\n   * @summary Initializes a new EventHandler object\n   * This constructor currently doesn't take any parameters, but it can be\n   * extended in the future to accept configuration options if needed.\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Handles an event with the provided arguments.\n   * Logs the event handling process, including the component name and the arguments passed.\n   *\n   * @param args - The arguments for the event handler.\n   * @returns void\n   */\n  handle(...args: unknown[]): void {\n    this.log\n      .for(this.handle)\n      .info(`component ${this.componentName} handling ${JSON.stringify(args)}`);\n  }\n\n  /**\n   * Handles an click event with the provided arguments.\n   * Logs the event handling process, including the component name and the arguments passed.\n   *\n   * @param args - The arguments for the event handler.\n   * @returns void\n   */\n  handleClick(...args: unknown[]): void {\n    this.log\n      .for(this.handleClick)\n      .info(\n        `component ${this.componentName} handling click ${JSON.stringify(args)}`\n      );\n  }\n\n  /**\n   * Handles an click event with the provided arguments.\n   * Logs the event handling process, including the component name and the arguments passed.\n   *\n   * @param args - The arguments for the event handler.\n   * @returns void\n   */\n  handleAction(...args: unknown[]): void {\n    this.log\n      .for(this.handleAction)\n      .info(\n        `component ${this.componentName} handling action ${JSON.stringify(args)}`\n      );\n  }\n}\n","import { LoggedClass } from \"@decaf-ts/logging\";\n\nexport class DecafTranslateService extends LoggedClass {\n  translate(key: string, params?: Record<string, any>): any {\n    this.log\n      .for(this.translate)\n      .info(\n        `Must translate ${key} with params ${JSON.stringify(params || {})}`\n      );\n  }\n\n  instant(key: string, params?: Record<string, any>): any {\n    this.log\n      .for(this.instant)\n      .info(\n        `Must translate ${key} with params ${JSON.stringify(params || {})}`\n      );\n  }\n}\n","/**\n * @description Module that extends the Model prototype with rendering capabilities\n * @summary Adds the render method to all Model instances from decorator-validation\n * This module implements the Renderable interface for the Model class by adding a render method\n * to its prototype. This allows any Model instance to be rendered using the RenderingEngine.\n * @module model/overrides\n * @memberOf module:ui-decorators/model\n */\n\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { RenderingEngine } from \"../ui/Rendering\";\nimport { Constructor, DecorationKeys, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  CrudOperationKeys,\n  getUIAttributeKey,\n  RenderingError,\n  UIElementMetadata,\n  UIKeys,\n  UIModelMetadata,\n} from \"../ui/index\";\nimport \"./model\";\nimport { NotFoundError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Renders the model using the appropriate rendering engine\n * @summary Delegates rendering to the RenderingEngine based on model metadata\n * This method implements the render method from the Renderable interface for all Model instances.\n * It uses the RenderingEngine to determine how to render the model based on its metadata.\n *\n * @template M Type of the model being rendered\n * @param {any[]} args Additional arguments to pass to the rendering engine\n * @return {any} The rendered output in the format determined by the rendering engine\n */\nModel.prototype.render = function <M extends Model>(this: M, ...args: any[]) {\n  return RenderingEngine.render(this, ...args);\n};\n\n(Model as any).renderedBy = function <M extends Model>(\n  model: Constructor<M>\n): string | undefined {\n  return Metadata.get(model, Metadata.key(UIKeys.REFLECT, UIKeys.RENDERED_BY));\n}.bind(Model);\n\n(Model as any).uiPropertiesOf = function <M extends Model>(\n  model: Constructor<M>\n): string[] | undefined {\n  const meta = Metadata.get(\n    model,\n    Metadata.key(UIKeys.REFLECT, DecorationKeys.PROPERTIES)\n  );\n  if (!meta) return undefined;\n  return Object.keys(meta);\n}.bind(Model);\n\n(Model as any).uiDecorationOf = function <M extends Model>(\n  model: Constructor<M>,\n  prop: string,\n  key?: string\n): any {\n  const meta = Metadata.get(\n    model,\n    Metadata.key(UIKeys.REFLECT, DecorationKeys.PROPERTIES, prop)\n  );\n  if (!meta) return undefined;\n  if (!key) return meta;\n  return meta[key];\n};\n\n(Model as any).uiModelOf = function <M extends Model>(\n  model: Constructor<M>\n): UIModelMetadata {\n  return Metadata.get(model, Metadata.key(UIKeys.REFLECT, UIKeys.UIMODEL));\n};\n\n(Model as any).uiElementOf = function <M extends Model>(\n  model: Constructor<M>,\n  prop: string\n): UIElementMetadata | undefined {\n  return Metadata.get(model, getUIAttributeKey(prop, UIKeys.ELEMENT));\n};\n\n(Model as any).uiListModelOf = function <M extends Model>(\n  model: Constructor<M>\n): UIModelMetadata {\n  return Metadata.get(model, Metadata.key(UIKeys.REFLECT, UIKeys.UILISTMODEL));\n};\n\n(Model as any).uiHandlersFor = function <M extends Model>(\n  model: Constructor<M>\n): UIModelMetadata {\n  return Metadata.get(model, Metadata.key(UIKeys.REFLECT, UIKeys.HANDLERS));\n};\n\n(Model as any).uiLayoutOf = function <M extends Model>(\n  model: Constructor<M>\n): UIModelMetadata {\n  return Metadata.get(model, Metadata.key(UIKeys.REFLECT, UIKeys.UILAYOUT));\n};\n\n(Model as any).uiIsHidden = function <M extends Model>(\n  model: Constructor<M>,\n  prop: string\n): boolean {\n  return !!Metadata.get(model, getUIAttributeKey(prop, UIKeys.HIDDEN));\n};\n\n(Model as any).uiIsHiddenOn = function <M extends Model>(\n  model: Constructor<M>,\n  prop: string,\n  op?: CrudOperationKeys\n): CrudOperationKeys[] | boolean {\n  const meta = Metadata.get(model, getUIAttributeKey(prop, UIKeys.HIDDEN));\n  if (!meta) return false;\n  if (!op) return meta as CrudOperationKeys[];\n  return (meta as CrudOperationKeys[]).includes(op);\n};\n\n(Model as any).uiTypeOf = function <M extends Model>(\n  model: Constructor<M>,\n  prop: string\n): UIModelMetadata {\n  const meta = Metadata.get(\n    model,\n    Metadata.key(UIKeys.REFLECT, DecorationKeys.PROPERTIES, prop)\n  );\n  if (!meta)\n    throw new NotFoundError(\n      `No metadata found for property '${prop}' on model '${model.name}'`\n    );\n  const keys = Object.keys(meta).filter((k) =>\n    [UIKeys.PROP, UIKeys.ELEMENT, UIKeys.CHILD].includes(k)\n  );\n  if (keys.length === 0)\n    throw new NotFoundError(\n      `No UI type metadata found for property '${prop}' on model '${model.name}'`\n    );\n  if (keys.length > 1)\n    throw new RenderingError(\n      `Only one type of decoration is allowed. Please choose between @uiprop, @uichild or @uielement`\n    );\n  return meta[keys[0]];\n};\n//\n// (Metadata as any).uiElements = function <M extends Model>(\n//   model: Constructor<M>\n// ): string[] | undefined {\n//   const props = Metadata.uiPropertiesOf(model);\n//   if (!props) return undefined;\n//   return props\n//     .map((prop) => Metadata.get(model, getUIAttributeKey(prop, UIKeys.ELEMENT)))\n//     .filter(Boolean);\n// }.bind(Model);\n\n(Model as any).uiListItems = function <M extends Model>(\n  this: Metadata,\n  model: Constructor<M>\n): string[] | undefined {\n  const meta = Metadata.get(\n    model,\n    Metadata.key(UIKeys.REFLECT, DecorationKeys.PROPERTIES)\n  );\n  if (!meta) return undefined;\n  return Object.keys(meta);\n}.bind(Model);\n","import { UIKeys } from \"../ui/constants\";\nimport {\n  UIHandlerMetadata,\n  UIListModelMetadata,\n  UIModelMetadata,\n  UILayoutMetadata,\n  IPagedComponentProperties,\n} from \"../ui/types\";\nimport { UIMediaBreakPoints } from \"../ui/constants\";\nimport { apply, Metadata, metadata } from \"@decaf-ts/decoration\";\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(\n      Metadata.key(UIKeys.REFLECT, UIKeys.UIMODEL),\n      meta\n    )(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(\n    metadata(Metadata.key(UIKeys.REFLECT, UIKeys.RENDERED_BY), engine)\n  );\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 uilistmodel\n * @category Class Decorators\n *\n * @example\n * // Basic usage with default tag (class name)\n * @uimodel()\n * @uilistmodel()\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 * @uilistmodel('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 uilistmodel\n *   participant Model\n *   participant RenderingEngine\n *   System->>uilistmodel: apply to Model\n *   uilistmodel->>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 uilistmodel(name?: string, props?: Record<string, any>) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  return (original: any, propertyKey?: any) => {\n    const meta: UIListModelMetadata = {\n      item: {\n        tag: name || original.name,\n        props: props,\n      },\n    };\n    return metadata(\n      Metadata.key(UIKeys.REFLECT, UIKeys.UILISTMODEL),\n      meta\n    )(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: UIHandlerMetadata = {\n      handlers: props,\n    };\n    return metadata(\n      Metadata.key(UIKeys.REFLECT, UIKeys.HANDLERS),\n      meta\n    )(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|boolean} [colsMode=1] Number of columns in the grid layout or a boolean for flex mode\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 *   @uilayoutprop(1, 1)\n *   header: string;\n *\n *   @attribute()\n *   @uilayoutprop(1, 2)\n *   leftContent: string;\n *\n *   @attribute()\n *   @uilayoutprop(2, 2)\n *   rightContent: string;\n * }\n *\n * // Create a responsive layout with custom breakpoint\n * @uilayout('section', true, 2, 'l')\n * class ResponsiveLayout extends Model {\n *   @attribute()\n *   @uilayoutprop(1, 1)\n *   title: string;\n *\n *   @attribute()\n *   @uilayoutprop(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(\n  tag: string,\n  colsMode: number | boolean = 1,\n  rows: number | string[] = 1,\n  props: any = {}\n) {\n  const config = Object.assign({\n    ...(typeof colsMode === \"boolean\"\n      ? {\n          flexMode: colsMode,\n          cols: 1,\n        }\n      : {\n          flexMode: false,\n          cols: colsMode,\n        }),\n    rows,\n    ...Object.assign({ breakpoint: UIMediaBreakPoints.LARGE }, props),\n  } as UILayoutMetadata);\n  return (original: any, propertyKey?: any) => {\n    metadata(Metadata.key(UIKeys.REFLECT, UIKeys.UILAYOUT), config)(original);\n    return uimodel(tag, config)(original, propertyKey);\n  };\n}\n\n/**\n * @description Decorator that creates a multi-step form model with page navigation\n * @summary Combines UI model functionality with stepped/wizard form configuration\n * This decorator creates a UI model that acts as a multi-step container with page navigation\n * capabilities. It is designed for wizard-style forms or multi-page workflows where users\n * progress through sequential steps. The decorator combines @uimodel with page-specific\n * properties and optional pagination controls.\n *\n * @param {string} tag - The HTML tag to use for the stepped form container\n * @param {number | IPagedComponentProperties[]} [pages=1] - Number of pages or an array of page definitions with metadata\n * @param {boolean} [paginated=false] - Whether to show pagination controls (e.g., prev/next buttons)\n * @param {any} [props={}] - Additional properties to pass to the container element\n * @return {Function} A class decorator function\n *\n * @function uisteppedmodel\n * @category Class Decorators\n *\n * @example\n * // Create a simple 3-step wizard form\n * @uisteppedmodel('div', 3, true)\n * class RegistrationWizard extends Model {\n *   // Page 1: Personal Info\n *   @attribute()\n *   @uipageprop(1)\n *   firstName: string;\n *\n *   @attribute()\n *   @uipageprop(1)\n *   lastName: string;\n *\n *   // Page 2: Contact Info\n *   @attribute()\n *   @uipageprop(2)\n *   email: string;\n *\n *   @attribute()\n *   @uipageprop(2)\n *   phone: string;\n *\n *   // Page 3: Confirmation\n *   @attribute()\n *   @uipageprop(3)\n *   acceptTerms: boolean;\n * }\n *\n * // Create a wizard with custom page definitions\n * @uisteppedmodel('section', [\n *   { title: 'Personal', icon: 'user' },\n *   { title: 'Contact', icon: 'email' },\n *   { title: 'Review', icon: 'check' }\n * ], true, { class: 'wizard-container' })\n * class OnboardingWizard extends Model {\n *   @attribute()\n *   @uipageprop(1)\n *   username: string;\n *\n *   @attribute()\n *   @uipageprop(2)\n *   email: string;\n *\n *   @attribute()\n *   @uipageprop(3)\n *   preferences: string;\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant System\n *   participant uisteppedmodel\n *   participant uimodel\n *   participant Model\n *   participant RenderingEngine\n *   participant PaginationController\n *   System->>uisteppedmodel: apply to Model\n *   uisteppedmodel->>uimodel: call with page config\n *   uimodel->>Model: adds model metadata with pages and pagination\n *   Model->>RenderingEngine: requests rendering as stepped form\n *   RenderingEngine->>PaginationController: initialize page navigation\n *   PaginationController->>System: renders current page with navigation controls\n */\nexport function uisteppedmodel(\n  tag: string,\n  pages: number | IPagedComponentProperties[] = 1,\n  paginated: boolean = false,\n  props: any = {}\n) {\n  let pageTitles: IPagedComponentProperties[] = [];\n  if (typeof pages === \"object\") {\n    pageTitles = pages as IPagedComponentProperties[];\n    pages = pageTitles.length;\n  }\n  return uimodel(tag, {\n    pages,\n    paginated,\n    pageTitles,\n    props,\n  });\n}\n","import \"@decaf-ts/decorator-validation\";\nimport { ModelBuilder } from \"@decaf-ts/decorator-validation\";\nimport {\n  uihandlers,\n  uilayout,\n  uilistmodel,\n  uimodel,\n  uisteppedmodel,\n  renderedBy,\n} from \"../model/decorators\";\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  interface ModelBuilder<M> {\n    decorateClass(decorator: ClassDecorator): ModelBuilder<M>;\n  }\n}\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  export interface ModelBuilder<M> {\n    uimodel(tag?: string, props?: Record<string, any>): ModelBuilder<M>;\n    renderedBy(engine: string): ModelBuilder<M>;\n    uilistmodel(name?: string, props?: Record<string, any>): ModelBuilder<M>;\n    uihandlers(props?: Record<string, any>): ModelBuilder<M>;\n    uilayout(\n      tag: string,\n      colsMode?: number | boolean,\n      rows?: number | string[],\n      props?: any\n    ): ModelBuilder<M>;\n    uisteppedmodel(\n      tag: string,\n      pages?: number | any[],\n      paginated?: boolean,\n      props?: any\n    ): ModelBuilder<M>;\n  }\n}\n\nconst prototype = ModelBuilder.prototype as ModelBuilder<any> & {\n  uimodel: (tag?: string, props?: Record<string, any>) => ModelBuilder<any>;\n  renderedBy: (engine: string) => ModelBuilder<any>;\n  uilistmodel: (name?: string, props?: Record<string, any>) => ModelBuilder<any>;\n  uihandlers: (props?: Record<string, any>) => ModelBuilder<any>;\n  uilayout: (\n    tag: string,\n    colsMode?: number | boolean,\n    rows?: number | string[],\n    props?: any\n  ) => ModelBuilder<any>;\n  uisteppedmodel: (\n    tag: string,\n    pages?: number | any[],\n    paginated?: boolean,\n    props?: any\n  ) => ModelBuilder<any>;\n};\n\nif (!prototype.decorateClass) {\n  prototype.decorateClass = function (decorator: ClassDecorator) {\n    if (!(this as any)._classDecorators) {\n      (this as any)._classDecorators = [];\n    }\n    (this as any)._classDecorators.push(decorator);\n    return this;\n  };\n}\n\nprototype.uimodel = function (tag?: string, props?: Record<string, any>) {\n  return this.decorateClass(uimodel(tag, props));\n};\n\nprototype.renderedBy = function (engine: string) {\n  return this.decorateClass(renderedBy(engine));\n};\n\nprototype.uilistmodel = function (name?: string, props?: Record<string, any>) {\n  return this.decorateClass(uilistmodel(name, props));\n};\n\nprototype.uihandlers = function (props?: Record<string, any>) {\n  return this.decorateClass(uihandlers(props));\n};\n\nprototype.uilayout = function (\n  tag: string,\n  colsMode?: number | boolean,\n  rows?: number | string[],\n  props?: any\n) {\n  return this.decorateClass(uilayout(tag, colsMode, rows, props));\n};\n\nprototype.uisteppedmodel = function (\n  tag: string,\n  pages?: number | any[],\n  paginated?: boolean,\n  props?: any\n) {\n  return this.decorateClass(uisteppedmodel(tag, pages, paginated, props));\n};\n","/**\n * @module ui-decorators/dashboard/constants\n * @summary Metadata keys for the dashboard-selectable-component decorator.\n * @description Namespaced keys used to store palette metadata on a\n * `@dashcomponent`-decorated class. Mirrors the `graph` submodule's\n * `GraphKeys` convention so the dashboard metadata family is isolated from\n * the UI model metadata keys.\n */\n\n/**\n * @description Metadata key constants for dashboard components.\n * @summary Collection of string keys used as metadata namespaces for\n * dashboard-selectable components. The `COMPONENT` key carries the palette\n * metadata object attached by `@dashcomponent()`.\n * @enum DashKeys\n * @memberOf module:ui-decorators/dashboard/constants\n */\nexport enum DashKeys {\n  /** Namespace root for all dashboard metadata. */\n  ROOT = \"dashboard\",\n  /** Key under which `@dashcomponent()` palette metadata is stored. */\n  COMPONENT = `${DashKeys.ROOT}.component`,\n}\n","/**\n * @module ui-decorators/dashboard/registry\n * @summary Dashboard-selectable component registry.\n * @description Module-level registry that tracks every `@dashcomponent`-\n * decorated constructor. The `@dashcomponent` decorator calls\n * {@link registerDashComponent} as a side-effect; consumers discover all\n * decorated classes via {@link dashComponents}.\n *\n * This follows the same pattern as the `graph` submodule's node registry and\n * the `InjectablesRegistry` in `injectable-decorators` — a private `Set`\n * rather than the `Metadata` internal helpers.\n */\n\nimport type { Constructor } from \"@decaf-ts/decoration\";\n\n/**\n * Internal registry of all `@dashcomponent`-decorated constructors.\n */\nconst DASH_COMPONENT_REGISTRY = new Set<Constructor>();\n\n/**\n * Appends a constructor to the dashboard component registry. Called by the\n * `@dashcomponent` decorator. Idempotent — re-decorating the same class does\n * not duplicate the entry.\n * @param ctor The `@dashcomponent`-decorated constructor.\n */\nexport function registerDashComponent(ctor: Constructor): void {\n  DASH_COMPONENT_REGISTRY.add(ctor);\n}\n\n/**\n * Returns all `@dashcomponent`-decorated constructors.\n * @returns A fresh array of constructors (mutable; does not expose the internal set).\n */\nexport function dashComponents(): Constructor[] {\n  return [...DASH_COMPONENT_REGISTRY];\n}\n\n/**\n * Clears the dashboard component registry. Intended for tests only.\n */\nexport function resetDashComponentRegistry(): void {\n  DASH_COMPONENT_REGISTRY.clear();\n}\n","/**\n * @module ui-decorators/dashboard/decorators\n * @summary The `@dashcomponent()` class decorator.\n * @description Decorator module that marks decaf model classes as\n * dashboard-selectable palette entries. Attaches the {@link DashComponentMetadata}\n * payload under {@link DashKeys.COMPONENT} and registers the class in the\n * dashboard registry as a side-effect.\n */\n\nimport {\n  apply,\n  Decoration,\n  metadata,\n} from \"@decaf-ts/decoration\";\nimport type { Constructor } from \"@decaf-ts/decoration\";\nimport { uimodel } from \"../model/decorators\";\nimport { DashKeys } from \"./constants\";\nimport type { DashComponentMetadata } from \"./types\";\nimport { registerDashComponent } from \"./registry\";\n\n/**\n * @description Class decorator that marks a class as dashboard-selectable.\n * @summary Attaches palette metadata (translation label key, default grid\n * size, configuration model reference) and registers the constructor in the\n * dashboard component registry, mirroring the graph `@node()` decorator.\n *\n * Usage:\n * ```ts\n * @dashcomponent(\"my.widget\", {\n *   label: \"my.widget.label\",\n *   defaultSize: { cols: 2, rows: 1 },\n *   model: MyWidgetConfigModel,\n * })\n * @model()\n * export class MyWidget extends Model { ... }\n * ```\n *\n * @param {string} [tag] The component tag (defaults to the class name).\n * @param {DashComponentMetadata} [dash] Palette metadata.\n * @param {Record<string, any>} [props] Ad-hoc props for the component.\n * @return {Function} A class decorator function.\n * @function dashcomponent\n * @category Class Decorators\n */\nexport function dashcomponent(\n  tag?: string,\n  dash?: DashComponentMetadata,\n  props?: Record<string, any>\n) {\n  function dashcomponent(\n    tag?: string,\n    dash?: DashComponentMetadata,\n    props?: Record<string, any>\n  ) {\n    const meta: DashComponentMetadata = {\n      tag: dash?.tag || tag,\n      ...dash,\n      defaultSize: dash?.defaultSize ?? { cols: 1, rows: 1 },\n    };\n    return function innerDashComponent(target: object) {\n      const result = apply(\n        uimodel(tag, props),\n        metadata(DashKeys.COMPONENT, meta)\n      )(target);\n      registerDashComponent(target as Constructor);\n      return result;\n    };\n  }\n\n  return Decoration.for(DashKeys.COMPONENT)\n    .define({\n      decorator: dashcomponent,\n      args: [tag, dash, props],\n    })\n    .apply();\n}\n","/**\n * @module ui-decorators/dashboard/reader\n * @summary Metadata readers for `@dashcomponent()`-decorated classes.\n * @description Read-side helpers that resolve the palette metadata and the\n * normalized {@link DashComponentDefinition} attached by `@dashcomponent()`.\n * Accept either a constructor or an instance, and apply defaults so consumers\n * never resolve undefined footprint values.\n */\n\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { DashKeys } from \"./constants\";\nimport type {\n  DashComponentDefinition,\n  DashComponentMetadata,\n} from \"./types\";\n\n/**\n * Normalizes a constructor-or-instance input to a constructor.\n * Falls back to the instance's own constructor and finally to the raw value\n * when {@link Metadata.constr} cannot resolve a usable constructor.\n * @param model The decorated class or an instance of it.\n */\nfunction resolveModel<M>(model: Constructor<M> | M): Constructor<M> {\n  const resolved = Metadata.constr(model as Constructor<M>);\n  if (typeof resolved === \"function\") return resolved as Constructor<M>;\n  const fallback = (model as { constructor?: Constructor<M> }).constructor;\n  if (typeof fallback === \"function\") return fallback as Constructor<M>;\n  return model as Constructor<M>;\n}\n\n/**\n * @description Returns the palette metadata attached by `@dashcomponent()`.\n * @summary Resolves the metadata object stored on the class, accepting either\n * the constructor or an instance.\n * @param {Constructor | object} model The decorated class or an instance of it.\n * @returns The palette metadata, or `undefined` when un-decorated.\n * @function dashComponentMetadataOf\n * @memberOf module:ui-decorators/dashboard/reader\n */\nexport function dashComponentMetadataOf<M>(\n  model: Constructor<M> | M\n): DashComponentMetadata | undefined {\n  const resolved = resolveModel(model);\n  return Metadata.get(resolved, DashKeys.COMPONENT) as\n    | DashComponentMetadata\n    | undefined;\n}\n\n/**\n * @description Resolves a normalized definition for a dashboard component.\n * @summary Applies defaults (tag from class name, size `{cols:1, rows:1}`)\n * so consumers never resolve undefined footprint values.\n * @param {Constructor | object} model The decorated class or an instance of it.\n * @returns A normalized {@link DashComponentDefinition}.\n * @function dashComponentDefinitionOf\n * @memberOf module:ui-decorators/dashboard/reader\n */\nexport function dashComponentDefinitionOf<M>(\n  model: Constructor<M> | M\n): DashComponentDefinition {\n  const resolved = resolveModel(model);\n  const meta = dashComponentMetadataOf(resolved) || {};\n  const tag = meta.tag || resolved.name;\n  return {\n    name: resolved.name,\n    tag,\n    label: meta.label,\n    defaultSize: meta.defaultSize ?? { cols: 1, rows: 1 },\n    model: meta.model,\n    props: meta.props,\n    metadata: meta.metadata,\n  };\n}\n","/**\n * @description UI decorators module for TypeScript applications\n * @summary A collection of decorators and utilities for building UI components in TypeScript applications.\n * This module exports functionality from both the model and UI submodules, providing decorators for\n * rendering, component definition, and UI state management.\n * @module ui-decorators\n */\n\nimport \"./overrides\";\nimport { Metadata } from \"@decaf-ts/decoration\";\nexport * from \"./overrides\";\nexport * from \"./model\";\nexport * from \"./ui\";\nexport * from \"./dashboard\";\n\n/**\n * @description Current package version string\n * @summary Stores the current package version for reference\n * @const VERSION\n * @memberOf module:ui-decorators\n */\nexport const VERSION = \"##VERSION##\";\n\n/**\n * @description Represents the current commit hash of the module build.\n * @summary Stores the current git commit hash for the package. The build replaces\n * the placeholder with the actual commit hash at publish time.\n * @const COMMIT\n */\nexport const COMMIT = \"##COMMIT##\";\n\n/**\n * @description Represents the full version string of the module.\n * @summary Stores the semver version and commit hash for the package.\n * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.\n * @const FULL_VERSION\n */\nexport const FULL_VERSION = \"##FULL_VERSION##\";\n\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["UIMediaBreakPoints","UIKeys","REFLECT","UIMODEL","RENDERED_BY","ELEMENT","PROP","CHILD","NAME","NAME_PREFIX","VALIDATION_MESSAGE","UILISTMODEL","UILISTPROP","UILAYOUT","UILAYOUTPROP","HANDLERS","TYPE","SUB_TYPE","HIDDEN","HIDE_FOR","SHOW_FOR","RENDER_IF","FORMAT","ORDER","PAGE","EVENTS","FIRST","LAST","READ_ONLY","SEQUENCE","REQUIRED","ValidationKeys","MIN","MIN_LENGTH","MAX","MAX_LENGTH","PATTERN","URL","STEP","DATE","EMAIL","PASSWORD","EQUALS","DIFF","LESS_THAN","LESS_THAN_OR_EQUAL","GREATER_THAN","GREATER_THAN_OR_EQUAL","ValidatableByType","EmailValidator","URLValidator","DateValidator","PasswordValidator","ValidatableByAttribute","RequiredValidator","MinValidator","MaxValidator","StepValidator","MinLengthValidator","MaxLengthValidator","PatternValidator","EqualsValidator","DiffValidator","LessThanValidator","LessThanOrEqualValidator","GreaterThanValidator","GreaterThanOrEqualValidator","HTML5DateFormat","HTML5InputTypes","BUTTON","CHECKBOX","COLOR","DATETIME_LOCAL","FILE","IMAGE","MONTH","NUMBER","RADIO","RANGE","RESET","SEARCH","SUBMIT","TEL","TEXT","TEXTAREA","SELECT","TIME","WEEK","HTML5CheckTypes","ComponentEventNames","Render","BackButtonClickEvent","Refresh","Click","Change","Submit","ValidationError","ThemeChange","FormGroupLoaded","TransactionHooks","BeforeRead","AfterRead","BeforeCreate","AfterCreate","BeforeUpdate","AfterUpdate","BeforeDelete","AfterDelete","ElementSizes","xsmall","small","medium","default","large","xLarge","auto","expand","block","half","full","ElementPositions","left","center","right","top","bottom","LayoutGridGaps","collapse","none","ActionRoles","cancel","confirm","submit","clear","back","OperationKeys","CREATE","READ","UPDATE","DELETE","WindowColorSchemes","light","dark","undefined","RenderingError","InternalError","constructor","msg","super","name","isClassConstructor","fn","test","String","getUIAttributeKey","prop","key","Metadata","DecorationKeys","PROPERTIES","formatByType","type","value","args","format","shift","formatDate","Date","parseValueByType","fieldProps","result","Array","parsed","isArray","map","v","ReservedModels","STRING","toLowerCase","join","parseToNumber","trim","length","parseDate","OBJECT","JSON","stringify","BOOLEAN","escapeHtml","isNaN","Number","tagsToReplace","replace","tag","revertHtml","generateUIModelID","model","id","now","pk","Model","e","RenderingEngine","this","cache","flavour","initialized","register","console","log","translate","toView","BIGINT","getClassDecoratorsMetadata","uiModelOf","uiListModelOf","uiHandlersFor","uiLayoutOf","filter","Boolean","sortChildrenByOrder","children","sort","a","b","aOrder","props","order","bOrder","weight","Primitives","indexOf","aWeight","bWeight","isCustomValidator","Object","values","includes","isValidatableByType","keys","isValidatableByAttribute","toAttributeValue","Error","toFieldDefinition","globalProps","generateId","inheritProps","globalPropsWithoutInherits","classDecorators","classDecorator","assign","item","handlers","uiDecorators","uiPropertiesOf","childProps","mapper","getPath","parent","validationDecorators","get","decs","uiDecorationOf","uiTypeOf","NotFoundError","hasHideOnDecorator","uiIsHidden","hasUiElementDecorator","uiElementOf","sorted","entries","k","forEach","dec","modelName","isPropertyModel","isModel","build","Clazz","submodel","constructable","clazzName","childrenGlobalProps","childOf","childDefinition","push","decProps","render","uiProps","visibilityProps","hideFor","showFor","path","validationDecs","message","basicType","child","find","c","endsWith","row","col","currentNamespaces","Set","namespaces","namespace","operation","hiddenOn","hidden","some","rendererId","engine","current","getOrBoot","obj","initialize","fromObject","renderedBy","hideOn","operations","object","propertyKey","propMetadata","renderIf","uiorder","uielement","serialize","original","metadata","uiprop","propName","target","uichild","clazz","customTypes","multiple","uilistprop","uilayoutprop","uipageprop","page","uion","event","handler","uionclick","uionrender","uitablecol","sequence","valueParserFn","UIValidator","Validator","getMessage","translateService","DecafComponent","LoggedClass","enableDarkMode","isDarkMode","route","borders","events","repository","_repository","for","info","componentName","refresh","preview","debug","parseHandlers","instance","handle","parseEvents","evt","DecafEventHandler","handleClick","handleAction","DecafTranslateService","params","instant","prototype","bind","meta","uiIsHiddenOn","op","uiListItems","uimodel","apply","uilistmodel","uihandlers","uilayout","colsMode","rows","config","flexMode","cols","breakpoint","LARGE","uisteppedmodel","pages","paginated","pageTitles","ModelBuilder","decorateClass","decorator","_classDecorators","DashKeys","DASH_COMPONENT_REGISTRY","registerDashComponent","ctor","add","dashComponents","resetDashComponentRegistry","dashcomponent","dash","defaultSize","innerDashComponent","COMPONENT","Decoration","define","resolveModel","resolved","constr","fallback","dashComponentMetadataOf","dashComponentDefinitionOf","label","VERSION","COMMIT","FULL_VERSION","PACKAGE_NAME","registerLibrary"],"mappings":"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"}