@decaf-ts/for-angular 0.0.3 → 0.0.5

package/dist/lib/esm2022/components/model-renderer/model-renderer.component.mjs

@@ -0,0 +1,137 @@
+import { Component, EventEmitter, Injector, Input, Output, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { Model, sf } from '@decaf-ts/decorator-validation';
+import { NgComponentOutlet } from '@angular/common';
+import { AngularEngineKeys, BaseComponentProps, NgxRenderingEngine2, } from '../../engine';
+import { ForAngularModule } from 'src/lib/for-angular.module';
+import { ComponentRendererComponent } from '../component-renderer/component-renderer.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @description Component for rendering dynamic models
+ * @summary This component is responsible for dynamically rendering models,
+ * handling model changes, and managing event subscriptions for the rendered components.
+ * It uses the NgxRenderingEngine2 to render the models and supports both string and Model inputs.
+ * @class
+ * @template M - Type extending Model
+ * @param {Injector} injector - Angular Injector for dependency injection
+ * @example
+ * <ngx-decaf-model-renderer
+ *   [model]="myModel"
+ *   [globals]="globalVariables"
+ *   (listenEvent)="handleEvent($event)">
+ * </ngx-decaf-model-renderer>
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant ModelRenderer
+ *   participant RenderingEngine
+ *   participant Model
+ *   App->>ModelRenderer: Input model
+ *   ModelRenderer->>Model: Parse if string
+ *   Model-->>ModelRenderer: Parsed model
+ *   ModelRenderer->>RenderingEngine: Render model
+ *   RenderingEngine-->>ModelRenderer: Rendered output
+ *   ModelRenderer->>ModelRenderer: Subscribe to events
+ *   ModelRenderer-->>App: Emit events
+ */
+export class ModelRendererComponent {
+    constructor(injector) {
+        this.injector = injector;
+        /**
+         * @description Global variables to be passed to the rendered component
+         */
+        this.globals = {};
+        /**
+         * @description Event emitter for custom events from the rendered component
+         */
+        this.listenEvent = new EventEmitter();
+        this.JSON = JSON;
+    }
+    /**
+     * @description Refreshes the rendered model
+     * @param {string | M} model - The model to be rendered
+     */
+    refresh(model) {
+        model =
+            typeof model === 'string'
+                ? Model.build({}, JSON.parse(model))
+                : model;
+        this.output = model.render(this.globals || {}, this.vcr, this.injector, this.inner);
+        if (this.output?.inputs)
+            this.rendererId = sf(AngularEngineKeys.RENDERED_ID, this.output.inputs['rendererId']);
+        this.instance = this.output?.instance;
+        this.subscribeEvents();
+    }
+    /**
+     * @description Lifecycle hook that is called when data-bound properties of a directive change
+     * @param {SimpleChanges} changes - Object containing changes
+     */
+    ngOnChanges(changes) {
+        if (changes[BaseComponentProps.MODEL]) {
+            const { currentValue, previousValue, firstChange } = changes[BaseComponentProps.MODEL];
+            this.refresh(currentValue);
+        }
+    }
+    /**
+     * @description Lifecycle hook that is called when a directive, pipe, or service is destroyed
+     * @return {Promise<void>}
+     */
+    async ngOnDestroy() {
+        if (this.instance) {
+            this.unsubscribeEvents();
+            await NgxRenderingEngine2.destroy();
+        }
+        this.output = undefined;
+    }
+    subscribeEvents() {
+        if (this.instance) {
+            const componentKeys = Object.keys(this.instance);
+            for (const key of componentKeys) {
+                const value = this.instance[key];
+                if (value instanceof EventEmitter)
+                    this.instance[key].subscribe((event) => {
+                        this.listenEvent.emit({
+                            component: this.output?.component.name || '',
+                            name: key,
+                            ...event,
+                        });
+                    });
+            }
+        }
+    }
+    /**
+     * @description Unsubscribes from events emitted by the rendered component
+     */
+    unsubscribeEvents() {
+        if (this.instance) {
+            const componentKeys = Object.keys(this.instance);
+            for (const key of componentKeys) {
+                const value = this.instance[key];
+                if (value instanceof EventEmitter)
+                    this.instance[key].unsubscribe();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ModelRendererComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ModelRendererComponent, isStandalone: true, selector: "ngx-decaf-model-renderer", inputs: { model: "model", globals: "globals", rendererId: "rendererId" }, outputs: { listenEvent: "listenEvent" }, viewQueries: [{ propertyName: "inner", first: true, predicate: ["inner"], descendants: true, read: TemplateRef, static: true }, { propertyName: "vcr", first: true, predicate: ["componentOuter"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: "  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "parent"], outputs: ["listenEvent"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ModelRendererComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [ForAngularModule, NgComponentOutlet, ComponentRendererComponent], selector: 'ngx-decaf-model-renderer', template: "  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { model: [{
+                type: Input,
+                args: [{ required: true }]
+            }], globals: [{
+                type: Input
+            }], inner: [{
+                type: ViewChild,
+                args: ['inner', { read: TemplateRef, static: true }]
+            }], rendererId: [{
+                type: Input
+            }], vcr: [{
+                type: ViewChild,
+                args: ['componentOuter', { static: true, read: ViewContainerRef }]
+            }], listenEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-renderer.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/model-renderer/model-renderer.component.ts","../../../../../src/lib/components/model-renderer/model-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Injector,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { Model, sf } from '@decaf-ts/decorator-validation';\nimport { NgComponentOutlet } from '@angular/common';\nimport {\n  AngularDynamicOutput,\n  AngularEngineKeys,\n  BaseComponentProps,\n  BaseCustomEvent,\n  NgxRenderingEngine2,\n  RenderedModel,\n} from '../../engine';\nimport { KeyValue, ModelRenderCustomEvent } from 'src/lib/engine/types';\nimport { ForAngularModule } from 'src/lib/for-angular.module';\nimport { Renderable } from '@decaf-ts/ui-decorators';\nimport { ComponentRendererComponent } from '../component-renderer/component-renderer.component';\n\n/**\n * @description Component for rendering dynamic models\n * @summary This component is responsible for dynamically rendering models,\n * handling model changes, and managing event subscriptions for the rendered components.\n * It uses the NgxRenderingEngine2 to render the models and supports both string and Model inputs.\n * @class\n * @template M - Type extending Model\n * @param {Injector} injector - Angular Injector for dependency injection\n * @example\n * <ngx-decaf-model-renderer\n *   [model]=\"myModel\"\n *   [globals]=\"globalVariables\"\n *   (listenEvent)=\"handleEvent($event)\">\n * </ngx-decaf-model-renderer>\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant ModelRenderer\n *   participant RenderingEngine\n *   participant Model\n *   App->>ModelRenderer: Input model\n *   ModelRenderer->>Model: Parse if string\n *   Model-->>ModelRenderer: Parsed model\n *   ModelRenderer->>RenderingEngine: Render model\n *   RenderingEngine-->>ModelRenderer: Rendered output\n *   ModelRenderer->>ModelRenderer: Subscribe to events\n *   ModelRenderer-->>App: Emit events\n */\n@Component({\n  standalone: true,\n  imports: [ForAngularModule, NgComponentOutlet, ComponentRendererComponent],\n  selector: 'ngx-decaf-model-renderer',\n  templateUrl: './model-renderer.component.html',\n  styleUrl: './model-renderer.component.scss',\n})\nexport class ModelRendererComponent<M extends Model>\n  implements OnChanges, OnDestroy, RenderedModel {\n\n  /**\n   * @description Input model to be rendered\n   * @summary Can be a Model instance or a JSON string representation of a model\n   */\n  @Input({ required: true })\n  model!: M | string | undefined;\n\n  /**\n   * @description Global variables to be passed to the rendered component\n   */\n  @Input()\n  globals: Record<string, unknown> = {};\n\n  /**\n   * @description Template reference for inner content\n   */\n  @ViewChild('inner', { read: TemplateRef, static: true })\n  inner?: TemplateRef<any>;\n\n  /**\n   * @description Output of the rendered model\n   */\n  output?: AngularDynamicOutput;\n\n  /**\n   * @description Unique identifier for the renderer\n   */\n  @Input()\n  rendererId?: string;\n\n  /**\n   * @description View container reference for dynamic component rendering\n   */\n  @ViewChild('componentOuter', { static: true, read: ViewContainerRef })\n  vcr!: ViewContainerRef;\n\n  /**\n   * @description Event emitter for custom events from the rendered component\n   */\n  @Output()\n  listenEvent = new EventEmitter<ModelRenderCustomEvent>();\n\n  /**\n   * @description Instance of the NgxRenderingEngine2\n   */\n  private render!: NgxRenderingEngine2;\n\n  /**\n   * @description Instance of the rendered component\n   */\n  private instance!: KeyValue | undefined;\n\n  constructor(private injector: Injector) {}\n\n  /**\n   * @description Refreshes the rendered model\n   * @param {string | M} model - The model to be rendered\n   */\n  private refresh(model: string | M) {\n    model =\n      typeof model === 'string'\n        ? (Model.build({}, JSON.parse(model)) as M)\n        : model;\n    this.output = (model as unknown as Renderable).render<AngularDynamicOutput>(\n      this.globals || {},\n      this.vcr,\n      this.injector,\n      this.inner,\n    );\n    if (this.output?.inputs)\n      this.rendererId = sf(\n        AngularEngineKeys.RENDERED_ID,\n        (this.output.inputs as Record<string, any>)['rendererId'] as string,\n      );\n    this.instance = this.output?.instance;\n    this.subscribeEvents();\n  }\n\n  /**\n   * @description Lifecycle hook that is called when data-bound properties of a directive change\n   * @param {SimpleChanges} changes - Object containing changes\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[BaseComponentProps.MODEL]) {\n      const { currentValue, previousValue, firstChange } = changes[BaseComponentProps.MODEL];\n      this.refresh(currentValue);\n    }\n  }\n\n  /**\n   * @description Lifecycle hook that is called when a directive, pipe, or service is destroyed\n   * @return {Promise<void>}\n   */\n  async ngOnDestroy(): Promise<void> {\n    if (this.instance) {\n      this.unsubscribeEvents();\n      await NgxRenderingEngine2.destroy();\n    }\n    this.output = undefined;\n  }\n\n  private subscribeEvents(): void {\n    if (this.instance) {\n      const componentKeys = Object.keys(this.instance);\n      for (const key of componentKeys) {\n        const value = this.instance[key];\n        if (value instanceof EventEmitter)\n          (this.instance as KeyValue)[key].subscribe((event: Partial<BaseCustomEvent>) => {\n            this.listenEvent.emit({\n              component: this.output?.component.name || '',\n              name: key,\n              ...event,\n            } as ModelRenderCustomEvent);\n          });\n      }\n    }\n  }\n\n  /**\n   * @description Unsubscribes from events emitted by the rendered component\n   */\n  private unsubscribeEvents(): void {\n    if (this.instance) {\n      const componentKeys = Object.keys(this.instance);\n      for (const key of componentKeys) {\n        const value = this.instance[key];\n        if (value instanceof EventEmitter)\n          this.instance[key].unsubscribe();\n      }\n    }\n  }\n\n  protected readonly JSON = JSON;\n}\n","  <ng-template #componentOuter></ng-template>\n  <ng-template #inner>\n    <div  [id]=\"rendererId || null\">\n      @for (child of output?.children; track child) {\n        @if(child?.children?.length) {\n          <ngx-decaf-component-renderer [parent]=\"child\" />\n        } @else {\n          <ng-container\n            #childComponents\n            *ngComponentOutlet=\"\n              child.component;\n              injector: child.injector;\n              inputs: child.inputs;\n              content:child.content;\n            \"\n          />\n        }\n      }\n    </div>\n  </ng-template>\n"]}

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

@@ -0,0 +1,18 @@
+/**
+ * @description Abstract base class for dynamic Angular modules
+ * @summary The DynamicModule serves as a base class for Angular modules that need to be
+ * dynamically loaded or configured at runtime. It provides a common type for the rendering
+ * engine to identify and work with dynamic modules.
+ * @class DynamicModule
+ * @example
+ * ```typescript
+ * @NgModule({
+ *   declarations: [MyComponent],
+ *   imports: [CommonModule]
+ * })
+ * export class MyDynamicModule extends DynamicModule {}
+ * ```
+ */
+export class DynamicModule {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRHluYW1pY01vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvZW5naW5lL0R5bmFtaWNNb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxNQUFNLE9BQWdCLGFBQWE7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEFic3RyYWN0IGJhc2UgY2xhc3MgZm9yIGR5bmFtaWMgQW5ndWxhciBtb2R1bGVzXG4gKiBAc3VtbWFyeSBUaGUgRHluYW1pY01vZHVsZSBzZXJ2ZXMgYXMgYSBiYXNlIGNsYXNzIGZvciBBbmd1bGFyIG1vZHVsZXMgdGhhdCBuZWVkIHRvIGJlXG4gKiBkeW5hbWljYWxseSBsb2FkZWQgb3IgY29uZmlndXJlZCBhdCBydW50aW1lLiBJdCBwcm92aWRlcyBhIGNvbW1vbiB0eXBlIGZvciB0aGUgcmVuZGVyaW5nXG4gKiBlbmdpbmUgdG8gaWRlbnRpZnkgYW5kIHdvcmsgd2l0aCBkeW5hbWljIG1vZHVsZXMuXG4gKiBAY2xhc3MgRHluYW1pY01vZHVsZVxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIEBOZ01vZHVsZSh7XG4gKiAgIGRlY2xhcmF0aW9uczogW015Q29tcG9uZW50XSxcbiAqICAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV1cbiAqIH0pXG4gKiBleHBvcnQgY2xhc3MgTXlEeW5hbWljTW9kdWxlIGV4dGVuZHMgRHluYW1pY01vZHVsZSB7fVxuICogYGBgXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBEeW5hbWljTW9kdWxlIHt9XG4iXX0=

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

@@ -0,0 +1,117 @@
+import { RenderingError } from '@decaf-ts/ui-decorators';
+import { InternalError, OperationKeys } from '@decaf-ts/db-decorators';
+import { NgxFormService } from './NgxFormService';
+import { sf } from '@decaf-ts/decorator-validation';
+/**
+ * @class NgxCrudFormField
+ * @implements {FieldProperties}
+ * @implements {ControlValueAccessor}
+ * @summary Abstract class representing a CRUD form field for Angular applications
+ * @description This class provides the base implementation for CRUD form fields in Angular,
+ * implementing both CrudFormField and ControlValueAccessor interfaces.
+ */
+export class NgxCrudFormField {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        /**
+         * @summary String formatting function
+         * @description Provides access to the sf function for error message formatting
+         * @prop {function(string, ...string): string} sf - String formatting function
+         */
+        this.sf = sf;
+        /**
+         * @summary Change callback function
+         * @description Function called when the field value changes
+         * @property {function(): unknown} onChange - onChange event handler
+         */
+        this.onChange = () => {
+        };
+        /**
+         * @summary Touch callback function
+         * @description Function called when the field is touched
+         * @property {function(): unknown} onTouch - onTouch event handler
+         */
+        this.onTouch = () => {
+        };
+    }
+    /**
+     * @summary Write value to the field
+     * @description Sets the value of the field
+     * @param {string} obj - The value to be set
+     */
+    writeValue(obj) {
+        this.value = obj;
+    }
+    /**
+     * @summary Register change callback
+     * @description Registers a function to be called when the field value changes
+     * @param {function(): unknown} fn - The function to be called on change
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * @summary Register touch callback
+     * @description Registers a function to be called when the field is touched
+     * @param {function(): unknown} fn - The function to be called on touch
+     */
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    /**
+     * @summary Set disabled state
+     * @description Sets the disabled state of the field
+     * @param {boolean} isDisabled - Whether the field should be disabled
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * @summary After view initialization logic
+     * @description Performs necessary setup after the view has been initialized
+     * @returns {HTMLElement} The parent element of the field
+     */
+    afterViewInit() {
+        let parent;
+        switch (this.operation) {
+            case OperationKeys.READ:
+            case OperationKeys.DELETE:
+                return this.component.nativeElement.parentElement;
+            case OperationKeys.CREATE:
+            case OperationKeys.UPDATE:
+                try {
+                    parent = NgxFormService.getParentEl(this.component.nativeElement, 'div');
+                }
+                catch (e) {
+                    throw new RenderingError(`Unable to retrieve parent form element for the ${this.operation}: ${e instanceof Error ? e.message : e}`);
+                }
+                // NgxFormService.register(parent.id, this.formGroup, this as AngularFieldDefinition);
+                return parent;
+            default:
+                throw new InternalError(`Invalid operation: ${this.operation}`);
+        }
+    }
+    /**
+     * @summary Cleanup on component destruction
+     * @description Unregisters the field when the component is destroyed
+     */
+    onDestroy() {
+        if (this.formGroup)
+            NgxFormService.unregister(this.formGroup);
+    }
+    /**
+     * @summary Get field errors
+     * @description Retrieves all errors associated with the field
+     * @returns {Array<{key: string, message: string}>} An array of error objects
+     */
+    getErrors(parent) {
+        const collapsableContainer = parent.closest('ion-accordion-group');
+        if (collapsableContainer)
+            collapsableContainer.setAttribute('value', 'open');
+        return Object.keys(this.formControl.errors ?? {}).map(key => ({
+            key: key,
+            message: key,
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NgxCrudFormField.js","sourceRoot":"","sources":["../../../../src/lib/engine/NgxCrudFormField.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE1E,OAAO,EAAkB,aAAa,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGvF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,OAAgB,gBAAgB;IAoDpC,YAAgC,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;QAStD;;;;WAIG;QACH,OAAE,GAAG,EAAE,CAAC;QAER;;;;WAIG;QACH,aAAQ,GAAkB,GAAG,EAAE;QAC/B,CAAC,CAAC;QAEF;;;;WAIG;QACH,YAAO,GAAkB,GAAG,EAAE;QAC9B,CAAC,CAAC;IA7BF,CAAC;IA+BD;;;;OAIG;IACH,UAAU,CAAC,GAAW;QACpB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,EAAiB;QAChC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,EAAiB;QACjC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAE,UAAmB;QACnC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,IAAI,MAAmB,CAAC;QACxB,QAAQ,IAAI,CAAC,SAAS,EAAE,CAAC;YACvB,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,MAAM;gBACvB,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC;YACpD,KAAK,aAAa,CAAC,MAAM,CAAC;YAC1B,KAAK,aAAa,CAAC,MAAM;gBACvB,IAAI,CAAC;oBACH,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;gBAC3E,CAAC;gBAAC,OAAO,CAAU,EAAE,CAAC;oBACpB,MAAM,IAAI,cAAc,CAAC,kDAAkD,IAAI,CAAC,SAAS,KAAK,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACtI,CAAC;gBACD,sFAAsF;gBACtF,OAAO,MAAM,CAAC;YAChB;gBACE,MAAM,IAAI,aAAa,CAAC,sBAAsB,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,SAAS;QACP,IAAG,IAAI,CAAC,SAAS;YACf,cAAc,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,MAAmB;QAC3B,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QACnE,IAAG,oBAAoB;YACrB,oBAAoB,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACrD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC5D,GAAG,EAAE,GAAG;YACR,OAAO,EAAE,GAAG;SACb,CAAC,CAAC,CAAC;IACN,CAAC;CACF","sourcesContent":["import { FieldProperties, RenderingError } from '@decaf-ts/ui-decorators';\nimport { PossibleInputTypes } from './types';\nimport { CrudOperations, InternalError, OperationKeys } from '@decaf-ts/db-decorators';\nimport { ControlValueAccessor, FormControl, FormGroup } from '@angular/forms';\nimport { ElementRef } from '@angular/core';\nimport { NgxFormService } from './NgxFormService';\nimport { sf } from '@decaf-ts/decorator-validation';\n\n/**\n * @class NgxCrudFormField\n * @implements {FieldProperties}\n * @implements {ControlValueAccessor}\n * @summary Abstract class representing a CRUD form field for Angular applications\n * @description This class provides the base implementation for CRUD form fields in Angular,\n * implementing both CrudFormField and ControlValueAccessor interfaces.\n */\nexport abstract class NgxCrudFormField implements ControlValueAccessor, FieldProperties {\n  /**\n   * @summary Reference to the component's element\n   * @description ElementRef representing the component's native element\n   */\n  component!: ElementRef;\n\n  /**\n   * @summary Current CRUD operation\n   * @description Represents the current CRUD operation being performed\n   */\n  operation!: CrudOperations;\n\n  /**\n   * @summary Form group for the field\n   * @description Angular FormGroup instance for the field\n   */\n  formGroup!: FormGroup | undefined;\n\n  formControl!: FormControl;\n\n  name!: string;\n\n  path!: string;\n\n  childOf?: string;\n\n  type!: PossibleInputTypes;\n\n  disabled?: boolean;\n\n  // Validation\n\n  format?: string;\n  hidden?: boolean;\n  max?: number | Date;\n  maxlength?: number;\n  min?: number | Date;\n  minlength?: number;\n  pattern?: string | undefined;\n  readonly?: boolean;\n  required?: boolean;\n  step?: number;\n  equals?: string;\n  different?: string;\n  lessThan?: string;\n  lessThanOrEqual?: string;\n  greaterThan?: string;\n  greaterThanOrEqual?: string;\n\n  value!: string | number | Date;\n\n  protected constructor(protected elementRef: ElementRef) {\n  }\n\n  /**\n   * @summary Parent HTML element\n   * @description Reference to the parent HTML element of the field\n   */\n  protected parent?: HTMLElement;\n\n  /**\n   * @summary String formatting function\n   * @description Provides access to the sf function for error message formatting\n   * @prop {function(string, ...string): string} sf - String formatting function\n   */\n  sf = sf;\n\n  /**\n   * @summary Change callback function\n   * @description Function called when the field value changes\n   * @property {function(): unknown} onChange - onChange event handler\n   */\n  onChange: () => unknown = () => {\n  };\n\n  /**\n   * @summary Touch callback function\n   * @description Function called when the field is touched\n   * @property {function(): unknown} onTouch - onTouch event handler\n   */\n  onTouch: () => unknown = () => {\n  };\n\n  /**\n   * @summary Write value to the field\n   * @description Sets the value of the field\n   * @param {string} obj - The value to be set\n   */\n  writeValue(obj: string): void {\n    this.value = obj;\n  }\n\n  /**\n   * @summary Register change callback\n   * @description Registers a function to be called when the field value changes\n   * @param {function(): unknown} fn - The function to be called on change\n   */\n  registerOnChange(fn: () => unknown): void {\n    this.onChange = fn;\n  }\n\n  /**\n   * @summary Register touch callback\n   * @description Registers a function to be called when the field is touched\n   * @param {function(): unknown} fn - The function to be called on touch\n   */\n  registerOnTouched(fn: () => unknown): void {\n    this.onTouch = fn;\n  }\n\n  /**\n   * @summary Set disabled state\n   * @description Sets the disabled state of the field\n   * @param {boolean} isDisabled - Whether the field should be disabled\n   */\n  setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /**\n   * @summary After view initialization logic\n   * @description Performs necessary setup after the view has been initialized\n   * @returns {HTMLElement} The parent element of the field\n   */\n  afterViewInit(): HTMLElement {\n    let parent: HTMLElement;\n    switch (this.operation) {\n      case OperationKeys.READ:\n      case OperationKeys.DELETE:\n        return this.component.nativeElement.parentElement;\n      case OperationKeys.CREATE:\n      case OperationKeys.UPDATE:\n        try {\n          parent = NgxFormService.getParentEl(this.component.nativeElement, 'div');\n        } catch (e: unknown) {\n          throw new RenderingError(`Unable to retrieve parent form element for the ${this.operation}: ${e instanceof Error ? e.message : e}`);\n        }\n        // NgxFormService.register(parent.id, this.formGroup, this as AngularFieldDefinition);\n        return parent;\n      default:\n        throw new InternalError(`Invalid operation: ${this.operation}`);\n    }\n  }\n\n  /**\n   * @summary Cleanup on component destruction\n   * @description Unregisters the field when the component is destroyed\n   */\n  onDestroy(): void {\n    if(this.formGroup)\n      NgxFormService.unregister(this.formGroup);\n  }\n\n  /**\n   * @summary Get field errors\n   * @description Retrieves all errors associated with the field\n   * @returns {Array<{key: string, message: string}>} An array of error objects\n   */\n  getErrors(parent: HTMLElement): { key: string; message: string; }[] {\n    const collapsableContainer = parent.closest('ion-accordion-group');\n    if(collapsableContainer)\n      collapsableContainer.setAttribute('value', 'open');\n    return Object.keys(this.formControl.errors ?? {}).map(key => ({\n      key: key,\n      message: key,\n    }));\n  }\n}\n"]}