@decaf-ts/for-angular 0.0.4 → 0.0.5

package/dist/lib/esm2022/engine/constants.mjs

@@ -0,0 +1,160 @@
+import { UIKeys } from '@decaf-ts/ui-decorators';
+import { VALIDATION_PARENT_KEY } from '@decaf-ts/decorator-validation';
+/**
+ * @description Angular engine key constants
+ * @summary Contains key strings used by the Angular rendering engine for reflection,
+ * dynamic component creation, and other engine operations.
+ * @typedef {Object} AngularEngineKeys
+ * @property {string} REFLECT - Prefix for reflection metadata keys
+ * @property {string} DYNAMIC - Key for dynamic component identification
+ * @property {string} ANNOTATIONS - Key for component annotations
+ * @property {string} ECMP - Key for embedded components
+ * @property {string} NG_REFLECT - Prefix for Angular reflection attributes
+ * @property {string} RENDERED - Prefix for rendered component markers
+ * @property {string} MAPPER - Key for property mappers
+ * @property {string} CHILDREN - Key for child components
+ * @property {string} LISTABLE - Key for listable components
+ * @property {string} RENDER - Key for renderable components
+ * @property {string} RENDERED_ID - Template for rendered component IDs
+ * @property {string} PARENT - Key for comparison decorators and validators
+ * @const AngularEngineKeys
+ * @memberOf module:engine
+ */
+export const AngularEngineKeys = {
+    REFLECT: `${UIKeys.REFLECT}.angular.`,
+    DYNAMIC: 'dynamic-component',
+    ANNOTATIONS: '__annotations__',
+    ECMP: 'ecmp',
+    NG_REFLECT: 'ng-reflect-',
+    RENDERED: 'rendered-as-',
+    MAPPER: 'mapper',
+    CHILDREN: 'children',
+    LISTABLE: 'listable',
+    RENDER: 'render',
+    RENDERED_ID: 'rendered-as-{0}',
+    PARENT: '_parent',
+    VALIDATION_PARENT_KEY: VALIDATION_PARENT_KEY
+};
+/**
+ * @description Form validation state constants
+ * @summary Contains constants representing the possible validation states of a form.
+ * These are used to check and handle form validation throughout the application.
+ * @typedef {Object} FormConstants
+ * @property {string} VALID - Constant representing a valid form state
+ * @property {string} INVALID - Constant representing an invalid form state
+ * @const FormConstants
+ * @memberOf module:engine
+ */
+export const FormConstants = {
+    VALID: 'VALID',
+    INVALID: 'INVALID',
+};
+/**
+ * @description Event name constants
+ * @summary Enum containing constants for event names used throughout the application.
+ * These are used to standardize event naming and handling.
+ * @enum {string}
+ * @readonly
+ * @property {string} BACK_BUTTON_NAVIGATION - Event fired when back button navigation ends
+ * @property {string} REFRESH_EVENT - Event fired when a refresh action occurs
+ * @property {string} CLICK_EVENT - Event fired when a click action occurs
+ * @property {string} SUBMIT_EVENT - Event fired when a form submission occurs
+ * @memberOf module:engine
+ */
+export var EventConstants;
+(function (EventConstants) {
+    EventConstants["BACK_BUTTON_NAVIGATION"] = "backButtonNavigationEndEvent";
+    EventConstants["REFRESH_EVENT"] = "RefreshEvent";
+    EventConstants["CLICK_EVENT"] = "ClickEvent";
+    EventConstants["SUBMIT_EVENT"] = "SubmitEvent";
+})(EventConstants || (EventConstants = {}));
+/**
+ * @description Logger level constants
+ * @summary Enum defining the logging levels used in the application's logging system.
+ * Lower values represent more verbose logging, while higher values represent more critical logs.
+ * @enum {number}
+ * @readonly
+ * @property {number} ALL - Log everything (most verbose)
+ * @property {number} DEBUG - Log debug information
+ * @property {number} INFO - Log informational messages
+ * @property {number} WARN - Log warnings
+ * @property {number} ERROR - Log errors
+ * @property {number} CRITICAL - Log critical errors (least verbose)
+ * @memberOf module:engine
+ */
+export var LoggerLevels;
+(function (LoggerLevels) {
+    LoggerLevels[LoggerLevels["ALL"] = 0] = "ALL";
+    LoggerLevels[LoggerLevels["DEBUG"] = 1] = "DEBUG";
+    LoggerLevels[LoggerLevels["INFO"] = 2] = "INFO";
+    LoggerLevels[LoggerLevels["WARN"] = 3] = "WARN";
+    LoggerLevels[LoggerLevels["ERROR"] = 4] = "ERROR";
+    LoggerLevels[LoggerLevels["CRITICAL"] = 5] = "CRITICAL";
+})(LoggerLevels || (LoggerLevels = {}));
+;
+/**
+ * @description Route direction constants
+ * @summary Enum defining the possible navigation directions in the application.
+ * Used for controlling navigation flow and animation directions.
+ * @enum {string}
+ * @readonly
+ * @property {string} BACK - Navigate back to the previous page
+ * @property {string} FORWARD - Navigate forward to the next page
+ * @property {string} ROOT - Navigate to the root/home page
+ * @memberOf module:engine
+ */
+export var RouteDirections;
+(function (RouteDirections) {
+    RouteDirections["BACK"] = "back";
+    RouteDirections["FORWARD"] = "forward";
+    RouteDirections["ROOT"] = "root";
+})(RouteDirections || (RouteDirections = {}));
+/**
+ * @description Component tag name constants
+ * @summary Enum defining the tag names for custom components used in the application.
+ * These tag names are used for component registration and rendering.
+ * @enum {string}
+ * @readonly
+ * @property {string} LIST_ITEM - Tag name for list item component
+ * @property {string} LIST_INFINITE - Tag name for infinite scrolling list component
+ * @property {string} LIST_PAGINATED - Tag name for paginated list component
+ * @memberOf module:engine
+ */
+export var ComponentsTagNames;
+(function (ComponentsTagNames) {
+    ComponentsTagNames["LIST_ITEM"] = "ngx-decaf-list-item";
+    ComponentsTagNames["LIST_INFINITE"] = "ngx-decaf-list-infinite";
+    ComponentsTagNames["LIST_PAGINATED"] = "ngx-decaf-list-paginated";
+})(ComponentsTagNames || (ComponentsTagNames = {}));
+/**
+ * @description Base component property name constants
+ * @summary Enum defining the standard property names used by base components in the application.
+ * These property names are used for consistent property access across components.
+ * @enum {string}
+ * @readonly
+ * @property {string} MODEL - Property name for the component's data model
+ * @property {string} LOCALE - Property name for localization settings
+ * @property {string} PK - Property name for primary key
+ * @property {string} ITEMS - Property name for collection items
+ * @property {string} ROUTE - Property name for routing information
+ * @property {string} OPERATIONS - Property name for available operations
+ * @property {string} UID - Property name for unique identifier
+ * @property {string} TRANSLATABLE - Property name for translation flag
+ * @property {string} MAPPER - Property name for property mapper
+ * @property {string} INITIALIZED - Property name for initialization state
+ * @memberOf module:engine
+ */
+export var BaseComponentProps;
+(function (BaseComponentProps) {
+    BaseComponentProps["MODEL"] = "model";
+    BaseComponentProps["LOCALE"] = "locale";
+    BaseComponentProps["PK"] = "pk";
+    BaseComponentProps["ITEMS"] = "items";
+    BaseComponentProps["ROUTE"] = "route";
+    BaseComponentProps["OPERATIONS"] = "operations";
+    BaseComponentProps["UID"] = "uid";
+    BaseComponentProps["TRANSLATABLE"] = "translatable";
+    BaseComponentProps["MAPPER"] = "mapper";
+    BaseComponentProps["INITIALIZED"] = "initialized";
+})(BaseComponentProps || (BaseComponentProps = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/lib/engine/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,WAAW;IACrC,OAAO,EAAE,mBAAmB;IAC5B,WAAW,EAAE,iBAAiB;IAC9B,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,aAAa;IACzB,QAAQ,EAAE,cAAc;IACxB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,iBAAiB;IAC9B,MAAM,EAAE,SAAS;IACjB,qBAAqB,EAAE,qBAAqB;CAC7C,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACnB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAN,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,yEAAuD,CAAA;IACvD,gDAA8B,CAAA;IAC9B,4CAA0B,CAAA;IAC1B,8CAA4B,CAAA;AAC9B,CAAC,EALW,cAAc,KAAd,cAAc,QAKzB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAN,IAAY,YAOX;AAPD,WAAY,YAAY;IACtB,6CAAO,CAAA;IACP,iDAAS,CAAA;IACT,+CAAQ,CAAA;IACR,+CAAQ,CAAA;IACR,iDAAS,CAAA;IACT,uDAAY,CAAA;AACd,CAAC,EAPW,YAAY,KAAZ,YAAY,QAOvB;AAAA,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,gCAAa,CAAA;IACb,sCAAmB,CAAA;IACnB,gCAAa,CAAA;AACf,CAAC,EAJW,eAAe,KAAf,eAAe,QAI1B;AAGD;;;;;;;;;;GAUG;AACH,MAAM,CAAN,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,uDAAiC,CAAA;IACjC,+DAAyC,CAAA;IACzC,iEAA2C,CAAA;AAC7C,CAAC,EAJW,kBAAkB,KAAlB,kBAAkB,QAI7B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAN,IAAY,kBAWX;AAXD,WAAY,kBAAkB;IAC5B,qCAAe,CAAA;IACf,uCAAiB,CAAA;IACjB,+BAAS,CAAA;IACT,qCAAe,CAAA;IACf,qCAAe,CAAA;IACf,+CAAyB,CAAA;IACzB,iCAAW,CAAA;IACX,mDAA6B,CAAA;IAC7B,uCAAiB,CAAA;IACjB,iDAA2B,CAAA;AAC7B,CAAC,EAXW,kBAAkB,KAAlB,kBAAkB,QAW7B","sourcesContent":["import { UIKeys } from '@decaf-ts/ui-decorators';\nimport { VALIDATION_PARENT_KEY } from '@decaf-ts/decorator-validation';\n\n/**\n * @description Angular engine key constants\n * @summary Contains key strings used by the Angular rendering engine for reflection,\n * dynamic component creation, and other engine operations.\n * @typedef {Object} AngularEngineKeys\n * @property {string} REFLECT - Prefix for reflection metadata keys\n * @property {string} DYNAMIC - Key for dynamic component identification\n * @property {string} ANNOTATIONS - Key for component annotations\n * @property {string} ECMP - Key for embedded components\n * @property {string} NG_REFLECT - Prefix for Angular reflection attributes\n * @property {string} RENDERED - Prefix for rendered component markers\n * @property {string} MAPPER - Key for property mappers\n * @property {string} CHILDREN - Key for child components\n * @property {string} LISTABLE - Key for listable components\n * @property {string} RENDER - Key for renderable components\n * @property {string} RENDERED_ID - Template for rendered component IDs\n * @property {string} PARENT - Key for comparison decorators and validators\n * @const AngularEngineKeys\n * @memberOf module:engine\n */\nexport const AngularEngineKeys = {\n  REFLECT: `${UIKeys.REFLECT}.angular.`,\n  DYNAMIC: 'dynamic-component',\n  ANNOTATIONS: '__annotations__',\n  ECMP: 'ecmp',\n  NG_REFLECT: 'ng-reflect-',\n  RENDERED: 'rendered-as-',\n  MAPPER: 'mapper',\n  CHILDREN: 'children',\n  LISTABLE: 'listable',\n  RENDER: 'render',\n  RENDERED_ID: 'rendered-as-{0}',\n  PARENT: '_parent',\n  VALIDATION_PARENT_KEY: VALIDATION_PARENT_KEY\n};\n\n/**\n * @description Form validation state constants\n * @summary Contains constants representing the possible validation states of a form.\n * These are used to check and handle form validation throughout the application.\n * @typedef {Object} FormConstants\n * @property {string} VALID - Constant representing a valid form state\n * @property {string} INVALID - Constant representing an invalid form state\n * @const FormConstants\n * @memberOf module:engine\n */\nexport const FormConstants = {\n  VALID: 'VALID',\n  INVALID: 'INVALID',\n};\n\n/**\n * @description Event name constants\n * @summary Enum containing constants for event names used throughout the application.\n * These are used to standardize event naming and handling.\n * @enum {string}\n * @readonly\n * @property {string} BACK_BUTTON_NAVIGATION - Event fired when back button navigation ends\n * @property {string} REFRESH_EVENT - Event fired when a refresh action occurs\n * @property {string} CLICK_EVENT - Event fired when a click action occurs\n * @property {string} SUBMIT_EVENT - Event fired when a form submission occurs\n * @memberOf module:engine\n */\nexport enum EventConstants {\n  BACK_BUTTON_NAVIGATION = 'backButtonNavigationEndEvent',\n  REFRESH_EVENT = 'RefreshEvent',\n  CLICK_EVENT = 'ClickEvent',\n  SUBMIT_EVENT = 'SubmitEvent',\n}\n\n/**\n * @description Logger level constants\n * @summary Enum defining the logging levels used in the application's logging system.\n * Lower values represent more verbose logging, while higher values represent more critical logs.\n * @enum {number}\n * @readonly\n * @property {number} ALL - Log everything (most verbose)\n * @property {number} DEBUG - Log debug information\n * @property {number} INFO - Log informational messages\n * @property {number} WARN - Log warnings\n * @property {number} ERROR - Log errors\n * @property {number} CRITICAL - Log critical errors (least verbose)\n * @memberOf module:engine\n */\nexport enum LoggerLevels {\n  ALL = 0,\n  DEBUG = 1,\n  INFO = 2,\n  WARN = 3,\n  ERROR = 4,\n  CRITICAL = 5\n};\n\n/**\n * @description Route direction constants\n * @summary Enum defining the possible navigation directions in the application.\n * Used for controlling navigation flow and animation directions.\n * @enum {string}\n * @readonly\n * @property {string} BACK - Navigate back to the previous page\n * @property {string} FORWARD - Navigate forward to the next page\n * @property {string} ROOT - Navigate to the root/home page\n * @memberOf module:engine\n */\nexport enum RouteDirections {\n  BACK = 'back',\n  FORWARD = 'forward',\n  ROOT = 'root',\n}\n\n\n/**\n * @description Component tag name constants\n * @summary Enum defining the tag names for custom components used in the application.\n * These tag names are used for component registration and rendering.\n * @enum {string}\n * @readonly\n * @property {string} LIST_ITEM - Tag name for list item component\n * @property {string} LIST_INFINITE - Tag name for infinite scrolling list component\n * @property {string} LIST_PAGINATED - Tag name for paginated list component\n * @memberOf module:engine\n */\nexport enum ComponentsTagNames {\n  LIST_ITEM = 'ngx-decaf-list-item',\n  LIST_INFINITE = 'ngx-decaf-list-infinite',\n  LIST_PAGINATED = 'ngx-decaf-list-paginated',\n}\n\n/**\n * @description Base component property name constants\n * @summary Enum defining the standard property names used by base components in the application.\n * These property names are used for consistent property access across components.\n * @enum {string}\n * @readonly\n * @property {string} MODEL - Property name for the component's data model\n * @property {string} LOCALE - Property name for localization settings\n * @property {string} PK - Property name for primary key\n * @property {string} ITEMS - Property name for collection items\n * @property {string} ROUTE - Property name for routing information\n * @property {string} OPERATIONS - Property name for available operations\n * @property {string} UID - Property name for unique identifier\n * @property {string} TRANSLATABLE - Property name for translation flag\n * @property {string} MAPPER - Property name for property mapper\n * @property {string} INITIALIZED - Property name for initialization state\n * @memberOf module:engine\n */\nexport enum BaseComponentProps {\n  MODEL = 'model',\n  LOCALE = 'locale',\n  PK = 'pk',\n  ITEMS = 'items',\n  ROUTE = 'route',\n  OPERATIONS = 'operations',\n  UID = 'uid',\n  TRANSLATABLE = 'translatable',\n  MAPPER = 'mapper',\n  INITIALIZED = 'initialized',\n}\n\n\n"]}

package/dist/lib/esm2022/engine/decorators.mjs

@@ -0,0 +1,38 @@
+import { apply, metadata } from '@decaf-ts/reflection';
+import { NgxRenderingEngine2 } from './NgxRenderingEngine2';
+import { AngularEngineKeys } from './constants';
+import { InternalError } from '@decaf-ts/db-decorators';
+import { reflectComponentType } from '@angular/core';
+/**
+ * @description Marks an Angular component as dynamically loadable
+ * @summary Decorator that registers an Angular component with the NgxRenderingEngine2 for dynamic loading.
+ * This decorator must be applied before the @Component decorator to properly extract component metadata.
+ * It adds metadata to the component class and registers it with the rendering engine using its selector.
+ * @function Dynamic
+ * @return {Function} A decorator function that can be applied to Angular component classes
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Component Class
+ *   participant D as Dynamic Decorator
+ *   participant R as NgxRenderingEngine2
+ *   participant M as Angular Metadata
+ *   C->>D: Apply decorator
+ *   D->>M: reflectComponentType()
+ *   M-->>D: Return component metadata
+ *   alt No metadata found
+ *     D->>D: Throw InternalError
+ *   else Metadata found
+ *     D->>R: registerComponent(selector, constructor)
+ *     D->>C: Apply metadata
+ *   end
+ * @category Decorators
+ */
+export function Dynamic() {
+    return apply((original) => {
+        const metadata = reflectComponentType(original);
+        if (!metadata)
+            throw new InternalError(`Could not find Component metadata. @Dynamic decorator must come above @Component`);
+        NgxRenderingEngine2.registerComponent(metadata.selector, original);
+    }, metadata(NgxRenderingEngine2.key(AngularEngineKeys.DYNAMIC), true));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm2022/engine/index.mjs

@@ -0,0 +1,16 @@
+/**
+ * @module engine
+ * @description Angular rendering engine for Decaf applications
+ * @summary The engine module provides core functionality for rendering Angular components
+ * in Decaf applications. It includes constants, decorators, rendering engines, and utility types
+ * that enable dynamic component creation, property mapping, and component lifecycle management.
+ * Key exports include {@link NgxRenderingEngine}, {@link DynamicModule}, and various decorators
+ * for component configuration.
+ */
+export * from './constants';
+export * from './decorators';
+export * from './DynamicModule';
+export * from './NgxRenderingEngine';
+export * from './NgxRenderingEngine2';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2VuZ2luZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUNILGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGVuZ2luZVxuICogQGRlc2NyaXB0aW9uIEFuZ3VsYXIgcmVuZGVyaW5nIGVuZ2luZSBmb3IgRGVjYWYgYXBwbGljYXRpb25zXG4gKiBAc3VtbWFyeSBUaGUgZW5naW5lIG1vZHVsZSBwcm92aWRlcyBjb3JlIGZ1bmN0aW9uYWxpdHkgZm9yIHJlbmRlcmluZyBBbmd1bGFyIGNvbXBvbmVudHNcbiAqIGluIERlY2FmIGFwcGxpY2F0aW9ucy4gSXQgaW5jbHVkZXMgY29uc3RhbnRzLCBkZWNvcmF0b3JzLCByZW5kZXJpbmcgZW5naW5lcywgYW5kIHV0aWxpdHkgdHlwZXNcbiAqIHRoYXQgZW5hYmxlIGR5bmFtaWMgY29tcG9uZW50IGNyZWF0aW9uLCBwcm9wZXJ0eSBtYXBwaW5nLCBhbmQgY29tcG9uZW50IGxpZmVjeWNsZSBtYW5hZ2VtZW50LlxuICogS2V5IGV4cG9ydHMgaW5jbHVkZSB7QGxpbmsgTmd4UmVuZGVyaW5nRW5naW5lfSwge0BsaW5rIER5bmFtaWNNb2R1bGV9LCBhbmQgdmFyaW91cyBkZWNvcmF0b3JzXG4gKiBmb3IgY29tcG9uZW50IGNvbmZpZ3VyYXRpb24uXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vZGVjb3JhdG9ycyc7XG5leHBvcnQgKiBmcm9tICcuL0R5bmFtaWNNb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9OZ3hSZW5kZXJpbmdFbmdpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9OZ3hSZW5kZXJpbmdFbmdpbmUyJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

package/dist/lib/esm2022/engine/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/engine/types.ts"],"names":[],"mappings":"","sourcesContent":["import { IonCheckbox, IonInput, IonSelect, IonTextarea } from '@ionic/angular';\nimport { TextFieldTypes } from '@ionic/core';\nimport { Injector, Type } from '@angular/core';\nimport { FormControl, FormGroup } from '@angular/forms';\nimport { FieldProperties } from '@decaf-ts/ui-decorators';\n\nexport type KeyValue = Record<string, any>;\n\n/**\n * @description Element size options for UI components\n * @summary Defines the possible size values that can be applied to UI elements.\n * These sizes control the dimensions and layout behavior of components.\n * @typedef {('small'|'medium'|'large'|'xlarge'|'2xlarge'|'auto'|'expand'|'block')} ElementSizes\n * @memberOf module:engine\n */\nexport type ElementSizes =\n  | 'small'\n  | 'medium'\n  | 'large'\n  | 'xlarge'\n  | '2xlarge'\n  | 'auto'\n  | 'expand'\n  | 'block';\n\n/**\n * @description Basic position options for UI elements\n * @summary Defines the possible position values that can be applied to UI elements.\n * These positions control the alignment and placement of components.\n * @typedef {('left'|'center'|'right'|'top'|'bottom')} ElementPositions\n * @memberOf module:engine\n */\nexport type ElementPositions = 'left' | 'center' | 'right' | 'top' | 'bottom';\n\n/**\n * @description Extended position options for flex layouts\n * @summary Extends the basic ElementPositions with additional flex-specific position values.\n * These positions are used for controlling alignment and distribution in flex containers.\n * @typedef {(ElementPositions|'stretch'|'middle'|'around'|'between')} FlexPositions\n * @memberOf module:engine\n */\nexport type FlexPositions =\n  | ElementPositions\n  | 'stretch'\n  | 'middle'\n  | 'around'\n  | 'between';\n\n/**\n * @description Update mode options for form fields\n * @summary Defines when form field values should be updated in the model.\n * - 'change': Update on every change event\n * - 'blur': Update when the field loses focus\n * - 'submit': Update only when the form is submitted\n * @typedef {('change'|'blur'|'submit')} FieldUpdateMode\n * @memberOf module:engine\n */\nexport type FieldUpdateMode = 'change' | 'blur' | 'submit';\n\n/**\n * @description Metadata structure for Angular components\n * @summary Defines the structure of metadata for Angular components, including\n * change detection strategy, selector, standalone status, imports, template, and styles.\n * This is used for reflection and dynamic component creation.\n * @interface ComponentMetadata\n * @property {number} changeDetection - The change detection strategy number\n * @property {string} selector - The CSS selector for the component\n * @property {boolean} standalone - Whether the component is standalone\n * @property imports - Array of imported modules/components\n * @property {string} template - The HTML template for the component\n * @property {string[]} styles - Array of CSS styles for the component\n * @memberOf module:engine\n */\nexport interface ComponentMetadata {\n  changeDetection: number;\n  selector: string;\n  standalone: boolean;\n  imports: (new (...args: unknown[]) => unknown)[];\n  template: string;\n  styles: string[];\n}\n\n/**\n * @description Output structure from the Angular rendering engine\n * @summary Defines the structure of the output produced by the NgxRenderingEngine\n * when rendering a component. Contains the component type, inputs, injector,\n * content nodes, and child components.\n * @typedef {Object} AngularDynamicOutput\n * @property {Type<unknown>} component - The Angular component type\n * @property {string} [rendererId] - Optional unique ID for the rendered component\n * @property {Record<string, unknown>} [inputs] - Optional input properties for the component\n * @property {Injector} [injector] - Optional Angular injector for dependency injection\n * @property {Node[][]} [content] - Optional content nodes for projection\n * @property {AngularDynamicOutput[]} [children] - Optional child components\n * @property {Type<unknown>} [instance] - Optional component instance\n * @property {FormGroup} [formGroup] - Optional component FormGroup\n * @property {FormControl} [formControl] - Optional component FormControl\n * @memberOf module:engine\n */\nexport interface AngularDynamicOutput {\n  component: Type<unknown>;\n  rendererId?: string;\n  inputs?: Record<string, unknown>;\n  injector?: Injector;\n  content?: Node[][];\n  children?: AngularDynamicOutput[];\n  instance?: Type<unknown>;\n  formGroup?: FormGroup;\n  formControl?: FormControl;\n}\n\n/**\n * @description Interface for models that can be rendered\n * @summary Defines the basic structure for models that can be rendered by the engine.\n * Contains an optional rendererId that uniquely identifies the rendered instance.\n * @interface RenderedModel\n * @property {string} [rendererId] - Optional unique ID for the rendered model instance\n * @memberOf module:engine\n */\nexport interface RenderedModel {\n  rendererId?: string;\n}\n\n/**\n * @description Possible input types for form fields\n * @summary Defines the possible input types that can be used in form fields.\n * Includes standard HTML input types like checkbox, radio, and select,\n * as well as Ionic's TextFieldTypes and textarea.\n * @typedef {('checkbox'|'radio'|'select'|TextFieldTypes|'textarea')} PossibleInputTypes\n * @memberOf module:engine\n */\nexport type PossibleInputTypes =\n  | 'checkbox'\n  | 'radio'\n  | 'select'\n  | TextFieldTypes\n  | 'textarea';\n\n/**\n * @description Field definition for Angular components\n * @summary A comprehensive type that combines properties from various Ionic components\n * to define the structure of a field in an Angular form. It omits certain properties\n * from IonInput, picks specific properties from IonSelect, IonTextarea, and IonCheckbox,\n * and adds custom properties like type and className.\n * @typedef {Object} AngularFieldDefinition\n * @property {PossibleInputTypes} type - The type of input field\n * @property {string|string[]} className - CSS class name(s) for the field\n * @property {string} [cancelText] - Text for the cancel button (from IonSelect)\n * @property {string} [interface] - Interface style for select (from IonSelect)\n * @property {string} [selectedText] - Text for selected option (from IonSelect)\n * @property {Object} [interfaceOptions] - Options for the interface (from IonSelect)\n * @property {number} [rows] - Number of rows for textarea (from IonTextarea)\n * @property {number} [cols] - Number of columns for textarea (from IonTextarea)\n * @property {string} [alignment] - Alignment of checkbox (from IonCheckbox)\n * @property {string} [justify] - Justification of checkbox (from IonCheckbox)\n * @property {boolean} [checked] - Whether checkbox is checked (from IonCheckbox)\n * @memberOf module:engine\n */\nexport type AngularFieldDefinition = Omit<\n  IonInput,\n  | 'ionInput'\n  | 'ionFocus'\n  | 'ionChange'\n  | 'ionBlur'\n  | 'getInputElement'\n  | 'setFocus'\n  | 'label'\n  | 'el'\n  | 'z'\n  | 'type'\n> &\n  Pick<\n    IonSelect,\n    'cancelText' | 'interface' | 'selectedText' | 'interfaceOptions'\n  > &\n  Pick<IonTextarea, 'rows' | 'cols'> &\n  Pick<IonCheckbox, 'alignment' | 'justify' | 'checked'> & {\n  type: PossibleInputTypes;\n  className: string | string[];\n} & Record<string, unknown>;\n\n/**\n * @description String or boolean representation of a boolean value\n * @summary Represents a value that can be either a boolean or a string representation of a boolean.\n * This is useful for handling attribute values that can be specified as either strings or booleans.\n * @typedef {('true'|'false'|boolean)} StringOrBoolean\n * @memberOf module:engine\n */\nexport type StringOrBoolean = 'true' | 'false' | boolean;\n\n/**\n * @description Option type for select inputs\n * @summary Extends the InputOption interface with a selected property to indicate\n * whether the option is selected by default.\n * @memberOf module:engine\n */\nexport type SelectOption = InputOption & { selected?: boolean };\n\n/**\n * @description Option type for radio inputs\n * @summary Extends the InputOption interface with a checked property to indicate\n * whether the option is checked by default.\n * @memberOf module:engine\n */\nexport type RadioOption = InputOption & { checked?: boolean };\n\n/**\n * @description Option type for checkbox inputs\n * @summary Alias for RadioOption, as checkbox options have the same structure as radio options.\n * @typedef {RadioOption} CheckboxOption\n * @memberOf module:engine\n */\nexport type CheckboxOption = RadioOption;\n\n/**\n * @description Base option type for input components\n * @summary Defines the common structure for options used in select, radio, and checkbox inputs.\n * Contains properties for the display text, value, disabled state, CSS class, and icon.\n * @interface InputOption\n * @property {string} text - The display text for the option\n * @property {string|number} value - The value associated with the option\n * @property {StringOrBoolean} [disabled] - Whether the option is disabled\n * @property {string} [className] - CSS class name for styling the option\n * @property {string} [icon] - Icon to display with the option\n * @memberOf module:engine\n */\nexport interface InputOption {\n  text: string;\n  value: string | number;\n  disabled?: StringOrBoolean;\n  className?: string;\n  icon?: string;\n}\n\n/**\n * @description Target options for HTML forms\n * @summary Defines the possible target values for HTML forms, including standard targets\n * like '_blank', '_self', '_parent', and '_top', as well as custom string values.\n * @typedef {('_blank'|'_self'|'_parent'|'_top'|string)} HTMLFormTarget\n * @memberOf module:engine\n */\nexport type HTMLFormTarget = '_blank' | '_self' | '_parent' | '_top' | string;\n\n// export interface IListItemProp {\n//   render?: string | boolean;\n//   translateProps?: string | string[];\n//   button?: StringOrBoolean;\n//   icon?: string;\n//   iconSlot?: 'start' | 'end';\n//   title?: string;\n//   descritpion?: string;\n//   info?: string;\n//   subinfo?: string;\n// }\n\n/**\n * @description Interface for list component refresh events\n * @summary Defines the structure of a refresh event for list components.\n * Contains an array of key-value pairs representing the new data for the list.\n * @interface IListComponentRefreshEvent\n * @property {KeyValue[]} data - Array of key-value pairs representing the new data\n * @memberOf module:engine\n */\nexport interface IListComponentRefreshEvent {\n  data: KeyValue[];\n}\n\nexport interface FormServiceControl {\n  control: FormGroup;\n  props: AngularFieldDefinition;\n}\n\n/**\n * @description Type for form service controls\n * @summary Defines the structure of form controls managed by the form service.\n * It's a nested record where the outer key is the form group name, the inner key\n * is the control name, and the value contains the form group and field properties.\n * @typedef {Record<string, Record<string, { control: FormGroup; props: AngularFieldDefinition }>>} FormServiceControls\n * @memberOf module:engine\n */\nexport type FormServiceControls = Record<\n  string,\n  Record<string, FormServiceControl>\n>;\n\n/**\n * @description Interface for model render custom events\n * @summary Defines the structure of custom events triggered during model rendering.\n * Contains the event detail, component name, and event name.\n * @interface ModelRenderCustomEvent\n * @property {BaseCustomEvent} detail - The detailed event information\n * @property {string} component - The component that triggered the event\n * @property {string} name - The name of the event\n * @memberOf module:engine\n */\nexport interface ModelRenderCustomEvent {\n  detail: BaseCustomEvent;\n  component: string;\n  name: string;\n}\n\n/**\n * @description Interface for list item custom events\n * @summary Defines the structure of custom events triggered by list items.\n * Extends BaseCustomEvent with additional properties for the action and primary key.\n * @interface ListItemCustomEvent\n * @property {string} action - The action performed on the list item\n * @property {string} [pk] - Optional primary key of the affected item\n * @property {any} data - The data associated with the event (inherited from BaseCustomEvent)\n * @property {HTMLElement} [target] - The target element (inherited from BaseCustomEvent)\n * @property {string} [name] - The name of the event (inherited from BaseCustomEvent)\n * @property {string} component - The component that triggered the event (inherited from BaseCustomEvent)\n * @memberOf module:engine\n */\nexport interface ListItemCustomEvent extends BaseCustomEvent {\n  action: string;\n  pk?: string;\n}\n\n/**\n * @description Base interface for custom events\n * @summary Defines the base structure for custom events in the application.\n * Contains properties for the event data, target element, name, and component.\n * @interface BaseCustomEvent\n * @property {any} data - The data associated with the event\n * @property {HTMLElement} [target] - The target element that triggered the event\n * @property {string} [name] - The name of the event\n * @property {string} component - The component that triggered the event\n * @memberOf module:engine\n */\nexport interface BaseCustomEvent {\n  data: any;\n  target?: HTMLElement;\n  name?: string;\n  component: string;\n}\n\n/**\n * @description Base interface for custom events\n * @summary Defines the base structure for custom events in the application.\n * Contains properties for the event data, target element, name, and component.\n * @interface BaseCustomEvent\n * @property {any} data - The data associated with the event\n * @property {HTMLElement} [target] - The target element that triggered the event\n * @property {string} [name] - The name of the event\n * @property {string} component - The component that triggered the event\n * @memberOf module:engine\n */\nexport type CrudFormEvent = BaseCustomEvent & {\n  handlers?: Record<string, any>;\n};// export type CrudFormEvent = BaseCustomEvent & {handlers?: Record<string, (...args: any[]) => any | Promise<any>>}\n\n\n\nexport interface ComponentInput extends FieldProperties {\n  updateMode?: FieldUpdateMode;\n  formGroup?: FormGroup;\n  formControl?: FormControl;\n}\n\nexport interface ComponentConfig {\n  component: string;\n  inputs: ComponentInput;\n  injector: any;\n  children?: ComponentConfig[];\n}\n\nexport type FormParentGroup = [FormGroup,  string];\n\n"]}

package/dist/lib/esm2022/for-angular.module.mjs

@@ -0,0 +1,118 @@
+import { NgModule, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonApp, IonRouterOutlet, IonSplitPane, IonImg, IonContent, IonText, IonButton, IonRouterLink, IonTitle } from '@ionic/angular/standalone';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslateModule, TranslatePipe } from '@ngx-translate/core';
+import { Logging } from '@decaf-ts/logging';
+import * as i0 from "@angular/core";
+const ComponentsAndModules = [
+    IonApp,
+    IonRouterOutlet,
+    IonSplitPane,
+    IonImg,
+    IonText,
+    IonTitle,
+    IonButton,
+    IonRouterLink,
+    IonContent,
+    CommonModule,
+    FormsModule,
+    ReactiveFormsModule,
+    TranslateModule,
+    TranslatePipe,
+];
+const log = Logging.for("for-angular");
+export function getLogger(instance) {
+    return log.for(instance);
+}
+/**
+ * @description Main Angular module for the Decaf framework
+ * @summary The ForAngularModule provides the core functionality for integrating Decaf with Angular applications.
+ * It imports and exports common Angular and Ionic components and modules needed for Decaf applications,
+ * including form handling, translation support, and Ionic UI components. This module can be imported
+ * directly or via the forRoot() method for proper initialization in the application's root module.
+ *
+ * @class ForAngularModule
+ * @example
+ * ```typescript
+ * // In your app module:
+ * @NgModule({
+ *   imports: [
+ *     ForAngularModule.forRoot(),
+ *     // other imports
+ *   ],
+ *   // ...
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export class ForAngularModule {
+    /**
+     * @description Creates a module with providers for root module import
+     * @summary This static method provides the proper way to import the ForAngularModule in the application's
+     * root module. It returns a ModuleWithProviders object that includes the ForAngularModule itself.
+     * Using forRoot() ensures that the module and its providers are properly initialized and only
+     * instantiated once in the application.
+     *
+     * @return {ModuleWithProviders<ForAngularModule>} The module with its providers
+     */
+    static forRoot() {
+        return {
+            ngModule: ForAngularModule,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ForAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ForAngularModule, imports: [IonApp,
+            IonRouterOutlet,
+            IonSplitPane,
+            IonImg,
+            IonText,
+            IonTitle,
+            IonButton,
+            IonRouterLink,
+            IonContent,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslateModule,
+            TranslatePipe], exports: [IonApp,
+            IonRouterOutlet,
+            IonSplitPane,
+            IonImg,
+            IonText,
+            IonTitle,
+            IonButton,
+            IonRouterLink,
+            IonContent,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslateModule,
+            TranslatePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ForAngularModule, imports: [IonApp,
+            IonRouterOutlet,
+            IonSplitPane,
+            IonImg,
+            IonText,
+            IonTitle,
+            IonButton,
+            IonContent,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslateModule,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ForAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: ComponentsAndModules,
+                    declarations: [],
+                    exports: ComponentsAndModules,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm2022/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBJbnRlcmZhY2UgZm9yIGNvbXBvbmVudHMgdGhhdCBob2xkIGFuIEVsZW1lbnRSZWZcbiAqIEBzdW1tYXJ5IERlZmluZXMgYSBjb21wb25lbnQgaG9sZGVyIGludGVyZmFjZSB0aGF0IHByb3ZpZGVzIGFjY2VzcyB0byB0aGUgdW5kZXJseWluZyBET00gZWxlbWVudCB0aHJvdWdoIEVsZW1lbnRSZWZcbiAqIEBpbnRlcmZhY2UgQ29tcG9uZW50SG9sZGVyXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1hbmd1bGFyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcG9uZW50SG9sZGVyIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBSZWZlcmVuY2UgdG8gdGhlIGNvbXBvbmVudCdzIERPTSBlbGVtZW50XG4gICAqIEBwcm9wZXJ0eSB7RWxlbWVudFJlZn0gY29tcG9uZW50IC0gVGhlIEVsZW1lbnRSZWYgaW5zdGFuY2UgcHJvdmlkaW5nIGFjY2VzcyB0byB0aGUgbmF0aXZlIERPTSBlbGVtZW50XG4gICAqL1xuICBjb21wb25lbnQ6IEVsZW1lbnRSZWY7XG59XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEludGVyZmFjZSBmb3IgZm9ybSBjb21wb25lbnRzIHRoYXQgaG9sZCBib3RoIGFuIEVsZW1lbnRSZWYgYW5kIGEgRm9ybUdyb3VwXG4gKiBAc3VtbWFyeSBFeHRlbmRzIENvbXBvbmVudEhvbGRlciB0byBpbmNsdWRlIGEgRm9ybUdyb3VwIGZvciBmb3JtIGhhbmRsaW5nIGNhcGFiaWxpdGllc1xuICogQGludGVyZmFjZSBGb3JtRWxlbWVudFxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItYW5ndWxhclxuICovXG5leHBvcnQgaW50ZXJmYWNlIEZvcm1FbGVtZW50IGV4dGVuZHMgQ29tcG9uZW50SG9sZGVyIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBUaGUgQW5ndWxhciBGb3JtR3JvdXAgYXNzb2NpYXRlZCB3aXRoIHRoaXMgZm9ybSBlbGVtZW50XG4gICAqIEBwcm9wZXJ0eSB7Rm9ybUdyb3VwfHVuZGVmaW5lZH0gZm9ybUdyb3VwIC0gVGhlIGZvcm0gZ3JvdXAgaW5zdGFuY2UgZm9yIG1hbmFnaW5nIGZvcm0gY29udHJvbHMgYW5kIHZhbGlkYXRpb25cbiAgICovXG4gIGZvcm1Hcm91cDogRm9ybUdyb3VwIHwgdW5kZWZpbmVkO1xufVxuIl19

package/dist/lib/esm2022/public-apis.mjs

@@ -0,0 +1,13 @@
+import '@decaf-ts/ui-decorators';
+export * from './components/model-renderer/model-renderer.component';
+export * from './components/crud-field/crud-field.component';
+export * from './components/crud-form/crud-form.component';
+export * from './engine';
+/**
+ * @description Angular integration for the Decaf framework
+ * @summary This module provides Angular components and services for integrating with the Decaf framework.
+ * It includes components for rendering models, CRUD operations, and form handling, as well as
+ * rendering engines and utility functions to facilitate Angular application development with Decaf.
+ * @module for-angular
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3B1YmxpYy1hcGlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8seUJBQXlCLENBQUM7QUFDakMsY0FBYyxzREFBc0QsQ0FBQztBQUNyRSxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyxVQUFVLENBQUM7QUFFekI7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICdAZGVjYWYtdHMvdWktZGVjb3JhdG9ycyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbW9kZWwtcmVuZGVyZXIvbW9kZWwtcmVuZGVyZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9jcnVkLWZpZWxkL2NydWQtZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9jcnVkLWZvcm0vY3J1ZC1mb3JtLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2VuZ2luZSc7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEFuZ3VsYXIgaW50ZWdyYXRpb24gZm9yIHRoZSBEZWNhZiBmcmFtZXdvcmtcbiAqIEBzdW1tYXJ5IFRoaXMgbW9kdWxlIHByb3ZpZGVzIEFuZ3VsYXIgY29tcG9uZW50cyBhbmQgc2VydmljZXMgZm9yIGludGVncmF0aW5nIHdpdGggdGhlIERlY2FmIGZyYW1ld29yay5cbiAqIEl0IGluY2x1ZGVzIGNvbXBvbmVudHMgZm9yIHJlbmRlcmluZyBtb2RlbHMsIENSVUQgb3BlcmF0aW9ucywgYW5kIGZvcm0gaGFuZGxpbmcsIGFzIHdlbGwgYXNcbiAqIHJlbmRlcmluZyBlbmdpbmVzIGFuZCB1dGlsaXR5IGZ1bmN0aW9ucyB0byBmYWNpbGl0YXRlIEFuZ3VsYXIgYXBwbGljYXRpb24gZGV2ZWxvcG1lbnQgd2l0aCBEZWNhZi5cbiAqIEBtb2R1bGUgZm9yLWFuZ3VsYXJcbiAqL1xuIl19