@decaf-ts/for-angular 0.0.23 → 0.0.25

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

@@ -38,6 +38,11 @@ export class ModelRendererComponent {
          * @description Global variables to be passed to the rendered component
          */
         this.globals = {};
+        /**
+         * @description Set if render content projection is allowed
+         * @default true
+         */
+        this.projectable = true;
         /**
          * @description Event emitter for custom events from the rendered component
          */
@@ -55,7 +60,7 @@ export class ModelRendererComponent {
             typeof model === 'string'
                 ? Model.build({}, model)
                 : model;
-        this.output = model.render(this.globals || {}, this.vcr, this.injector, this.inner);
+        this.output = model.render(this.globals || {}, this.vcr, this.injector, this.inner, this.projectable);
         if (this.output?.inputs)
             this.rendererId = sf(AngularEngineKeys.RENDERED_ID, this.output.inputs['rendererId']);
         this.instance = this.output?.instance;
@@ -113,7 +118,7 @@ export class ModelRendererComponent {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModelRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ModelRendererComponent, isStandalone: true, selector: "ngx-decaf-model-renderer", inputs: { model: "model", globals: "globals", rendererId: "rendererId" }, outputs: { listenEvent: "listenEvent" }, host: { properties: { "attr.id": "rendererId" } }, 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: "  <!-- Keep to avoid id conflicts -->\n  <div [id]=\"rendererId\"></div>\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", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "model", "parent"], outputs: ["listenEvent"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ModelRendererComponent, isStandalone: true, selector: "ngx-decaf-model-renderer", inputs: { model: "model", globals: "globals", projectable: "projectable", rendererId: "rendererId" }, outputs: { listenEvent: "listenEvent" }, host: { properties: { "attr.id": "rendererId" } }, 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: "  <!-- Keep to avoid id conflicts -->\n  <div [id]=\"rendererId\"></div>\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", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "children", "model", "parent"], outputs: ["listenEvent"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModelRendererComponent, decorators: [{
             type: Component,
@@ -123,6 +128,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 args: [{ required: true }]
             }], globals: [{
                 type: Input
+            }], projectable: [{
+                type: Input
             }], inner: [{
                 type: ViewChild,
                 args: ['inner', { read: TemplateRef, static: true }]
@@ -134,4 +141,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], 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  inject,\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  NgxRenderingEngine,\n  RenderedModel,\n} from '../../engine';\nimport { KeyValue, RendererCustomEvent } from '../../engine/types';\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 NgxRenderingEngine 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: [ NgComponentOutlet, ComponentRendererComponent],\n  selector: 'ngx-decaf-model-renderer',\n  templateUrl: './model-renderer.component.html',\n  styleUrl: './model-renderer.component.scss',\n  host: {'[attr.id]': 'rendererId'},\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<unknown>;\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<RendererCustomEvent>();\n\n  /**\n   * @description Instance of the rendered component\n   */\n  private instance!: KeyValue | undefined;\n\n  private injector: Injector = inject(Injector);\n\n  // constructor() {}\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({}, 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, unknown>)['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 } = 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 NgxRenderingEngine.destroy();\n    }\n    this.output = undefined;\n  }\n\n  private subscribeEvents(): void {\n    const component = this?.output?.component;\n    if (this.instance && component) {\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: component.name || '',\n              name: key,\n              ...event,\n            } as RendererCustomEvent);\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","  <!-- Keep to avoid id conflicts -->\n  <div [id]=\"rendererId\"></div>\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"]}
+//# 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  inject,\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  NgxRenderingEngine,\n  RenderedModel,\n} from '../../engine';\nimport { KeyValue, RendererCustomEvent } from '../../engine/types';\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 NgxRenderingEngine 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: [ NgComponentOutlet, ComponentRendererComponent],\n  selector: 'ngx-decaf-model-renderer',\n  templateUrl: './model-renderer.component.html',\n  styleUrl: './model-renderer.component.scss',\n  host: {'[attr.id]': 'rendererId'},\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 Set if render content projection is allowed\n   * @default true\n   */\n  @Input()\n  projectable: boolean = true;\n\n  /**\n   * @description Template reference for inner content\n   */\n  @ViewChild('inner', { read: TemplateRef, static: true })\n  inner?: TemplateRef<unknown>;\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<RendererCustomEvent>();\n\n  /**\n   * @description Instance of the rendered component\n   */\n  private instance!: KeyValue | undefined;\n\n  private injector: Injector = inject(Injector);\n\n  // constructor() {}\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({}, 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      this.projectable\n    );\n    if (this.output?.inputs)\n      this.rendererId = sf(\n        AngularEngineKeys.RENDERED_ID,\n        (this.output.inputs as Record<string, unknown>)['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 } = 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 NgxRenderingEngine.destroy();\n    }\n    this.output = undefined;\n  }\n\n  private subscribeEvents(): void {\n    const component = this?.output?.component;\n    if (this.instance && component) {\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: component.name || '',\n              name: key,\n              ...event,\n            } as RendererCustomEvent);\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","  <!-- Keep to avoid id conflicts -->\n  <div [id]=\"rendererId\"></div>\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/esm2022/components/stepped-form/stepped-form.component.mjs

@@ -0,0 +1,306 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { IonButton, IonIcon, IonSkeletonText, IonText } from '@ionic/angular/standalone';
+import { arrowForwardOutline, arrowBackOutline } from 'ionicons/icons';
+import { addIcons } from 'ionicons';
+import { OperationKeys } from '@decaf-ts/db-decorators';
+import { Dynamic, EventConstants, NgxFormService } from '../../engine';
+import { ComponentRendererComponent } from '../component-renderer/component-renderer.component';
+import { ModelRendererComponent } from '../model-renderer/model-renderer.component';
+import { timer } from 'rxjs';
+import { getLocaleContext } from '../../i18n/Loader';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+let SteppedFormComponent = class SteppedFormComponent {
+    /**
+     * @description Creates an instance of SteppedFormComponent.
+     * @summary Initializes a new SteppedFormComponent instance and registers the required
+     * Ionic icons for navigation buttons (forward and back arrows).
+     *
+     * @memberOf SteppedFormComponent
+     */
+    constructor() {
+        /**
+         * @description Number of pages in the stepped form.
+         * @summary Represents the total number of steps/pages in the multi-step form.
+         * This value is automatically calculated based on the page properties of the children
+         * or can be explicitly set. Each page represents a logical group of form fields.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf SteppedFormComponent
+         */
+        this.pages = 1;
+        /**
+         * @description The CRUD operation type for this form.
+         * @summary Defines the type of operation being performed (CREATE, READ, UPDATE, DELETE).
+         * This affects form behavior, validation rules, and field accessibility. For example,
+         * READ operations might disable form fields, while CREATE operations enable all fields.
+         *
+         * @type {CrudOperations}
+         * @default OperationKeys.CREATE
+         * @memberOf SteppedFormComponent
+         */
+        this.operation = OperationKeys.CREATE;
+        /**
+         * @description The initial page to display when the form loads.
+         * @summary Specifies which page of the multi-step form should be shown first.
+         * This allows starting the form at any step, useful for scenarios like editing
+         * existing data where you might want to jump to a specific section.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf SteppedFormComponent
+         */
+        this.startPage = 1;
+        /**
+         * @description Array of UI model metadata for the currently active page.
+         * @summary Contains only the UI model metadata for fields that should be displayed
+         * on the currently active page. This is a filtered subset of the children array,
+         * updated whenever the user navigates between pages.
+         *
+         * @type {UIModelMetadata[] | undefined}
+         * @memberOf SteppedFormComponent
+         */
+        this.activeChildren = undefined;
+        /**
+         * @description FormGroup for the currently active page.
+         * @summary The FormGroup instance that manages form controls and validation
+         * for the current page only. This is extracted from the main formGroup
+         * when using FormArray structure.
+         *
+         * @type {FormGroup | undefined}
+         * @memberOf SteppedFormComponent
+         */
+        this.activeFormGroup = undefined;
+        /**
+         * @description The currently active page number.
+         * @summary Tracks which page of the multi-step form is currently being displayed.
+         * This property is updated as users navigate through the form steps using
+         * the next/back buttons or programmatic navigation.
+         *
+         * @type {number}
+         * @memberOf SteppedFormComponent
+         */
+        this.activePage = 1;
+        /**
+         * @description Array representing the structure of pages.
+         * @summary Contains metadata about each page, including page numbers and indices.
+         * This array is built during initialization to organize the form fields into
+         * logical pages and provide navigation structure.
+         *
+         * @type {UIModelMetadata[]}
+         * @memberOf SteppedFormComponent
+         */
+        this.pagesArray = [];
+        /**
+         * @description Event emitter for form submission.
+         * @summary Emits events when the form is submitted, typically on the last page
+         * when all validation passes. The emitted event contains the form data and
+         * event type information for parent components to handle.
+         *
+         * @type {EventEmitter<BaseCustomEvent>}
+         * @memberOf SteppedFormComponent
+         */
+        this.submitEvent = new EventEmitter();
+        addIcons({ arrowForwardOutline, arrowBackOutline });
+    }
+    /**
+     * @description Initializes the component after Angular first displays the data-bound properties.
+     * @summary Sets up the stepped form by organizing children into pages, calculating the total
+     * number of pages, and initializing the active page. This method processes the UI model metadata
+     * to create a logical page structure and ensures proper page assignments for all form fields.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant S as SteppedFormComponent
+     *   participant F as Form Service
+     *
+     *   A->>S: ngOnInit()
+     *   S->>S: Set activePage = startPage
+     *   S->>S: Process children into pagesArray
+     *   S->>S: Calculate total pages
+     *   S->>S: Assign page props to children
+     *   S->>S: getCurrentFormGroup(activePage)
+     *   S->>F: Extract FormGroup for active page
+     *   F-->>S: Return activeFormGroup
+     *
+     * @memberOf SteppedFormComponent
+     */
+    ngOnInit() {
+        if (!this.locale)
+            this.locale = getLocaleContext("SteppedFormComponent");
+        this.activePage = this.startPage;
+        this.pagesArray = this.children.reduce((acc, curr, index) => {
+            const page = curr.props?.['page'] || index + 1;
+            if (!acc[page])
+                acc[page] = [];
+            acc[page].push({ index: page });
+            return acc;
+        }, []).filter(Boolean);
+        this.pages = this.pagesArray.length;
+        this.children = [...this.children.map((c) => {
+                if (!c.props)
+                    c.props = {};
+                const page = c.props['page'] || 1;
+                // prevent page overflow
+                c.props['page'] = page > this.pages ? this.pages : page;
+                return c;
+            })];
+        this.getCurrentFormGroup(this.activePage);
+    }
+    /**
+     * @description Cleanup method called when the component is destroyed.
+     * @summary Unsubscribes from any active timer subscriptions to prevent memory leaks.
+     * This is part of Angular's component lifecycle and ensures proper resource cleanup.
+     *
+     * @memberOf SteppedFormComponent
+     */
+    ngOnDestroy() {
+        if (this.timerSubscription)
+            this.timerSubscription.unsubscribe();
+    }
+    /**
+     * @description Handles navigation to the next page or form submission.
+     * @summary Validates the current page's form fields and either navigates to the next page
+     * or submits the entire form if on the last page. Form validation must pass before
+     * proceeding. On successful submission, emits a submit event with form data.
+     *
+     * @param {boolean} lastPage - Whether this is the last page of the form
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant S as SteppedFormComponent
+     *   participant F as Form Service
+     *   participant P as Parent Component
+     *
+     *   U->>S: Click Next/Submit
+     *   S->>F: validateFields(activeFormGroup)
+     *   F-->>S: Return validation result
+     *   alt Not last page and valid
+     *     S->>S: activePage++
+     *     S->>S: getCurrentFormGroup(activePage)
+     *   else Last page and valid
+     *     S->>F: getFormData(formGroup)
+     *     F-->>S: Return form data
+     *     S->>P: submitEvent.emit({data, name: SUBMIT})
+     *   end
+     *
+     * @memberOf SteppedFormComponent
+     */
+    handleNext(lastPage = false) {
+        const isValid = NgxFormService.validateFields(this.activeFormGroup);
+        if (!lastPage) {
+            if (isValid) {
+                this.activePage = this.activePage + 1;
+                this.getCurrentFormGroup(this.activePage);
+            }
+        }
+        else {
+            if (isValid) {
+                const data = Object.assign({}, ...Object.values(NgxFormService.getFormData(this.formGroup)));
+                this.submitEvent.emit({
+                    data,
+                    name: EventConstants.SUBMIT,
+                });
+            }
+        }
+    }
+    /**
+     * @description Handles navigation to the previous page.
+     * @summary Moves the user back to the previous page in the stepped form.
+     * This method decrements the active page number and updates the form
+     * group and children to display the previous page's content.
+     *
+     * @return {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant S as SteppedFormComponent
+     *
+     *   U->>S: Click Back
+     *   S->>S: activePage--
+     *   S->>S: getCurrentFormGroup(activePage)
+     *   Note over S: Update active form and children
+     *
+     * @memberOf SteppedFormComponent
+     */
+    handleBack() {
+        this.activePage = this.activePage - 1;
+        this.getCurrentFormGroup(this.activePage);
+    }
+    /**
+     * @description Updates the active form group and children for the specified page.
+     * @summary Extracts the FormGroup for the given page from the FormArray and filters
+     * the children to show only fields belonging to that page. Uses a timer to ensure
+     * proper Angular change detection when updating the activeChildren.
+     *
+     * @param {number} page - The page number to activate
+     * @return {void}
+     *
+     * @private
+     * @mermaid
+     * sequenceDiagram
+     *   participant S as SteppedFormComponent
+     *   participant F as FormArray
+     *   participant T as Timer
+     *
+     *   S->>F: Extract FormGroup at index (page - 1)
+     *   F-->>S: Return page FormGroup
+     *   S->>S: Set activeChildren = undefined
+     *   S->>T: timer(10).subscribe()
+     *   T-->>S: Filter children for active page
+     *   S->>S: Set activeChildren
+     *
+     * @memberOf SteppedFormComponent
+     */
+    getCurrentFormGroup(page) {
+        this.activeFormGroup = this.formGroup.at(page - 1);
+        this.activeChildren = undefined;
+        this.timerSubscription = timer(10).subscribe(() => {
+            this.activeChildren = this.children.filter(c => c.props?.['page'] === page);
+            console.log(this.activeChildren);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SteppedFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SteppedFormComponent, isStandalone: true, selector: "ngx-decaf-stepped-form", inputs: { locale: "locale", pages: "pages", operation: "operation", startPage: "startPage", children: "children", formGroup: "formGroup" }, outputs: { submitEvent: "submitEvent" }, ngImport: i0, template: "<form class=\"dcf-steped-form\" novalidate>\n  <div class=\"dcf-page-steps\">\n    <div>\n        @for(page of pagesArray; track $index;) {\n        <div [class.dcf-active]=\"activePage === $index + 1\" [class.dcf-passed]=\"($index + 1) < activePage\">{{ $index + 1 }}</div>\n      }\n    </div>\n  </div>\n  @if(formGroup) {\n    @for(child of activeChildren;  track $index) {\n      <ngx-decaf-component-renderer\n        [tag]=\"child?.tag\"\n        (listenEvent)=\"handleEvent($event)\"\n        [children]=\"child?.children || []\"\n        [globals]=\"{props: child.props}\"\n      />\n    }\n  } @else {\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n    <br />\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n  }\n\n  <div class=\"dcf-buttons-container dcf-grid dcf-grid-collapse dcf-flex dcf-flex-left\">\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button fill=\"clear\" (click)=\"handleBack()\" [disabled]=\"activePage <= 1\">\n        <ion-icon aria-hidden=\"true\" name=\"arrow-back-outline\"></ion-icon>\n          {{locale + '.previous' | translate}}\n      </ion-button>\n    </div>\n\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button [fill]=\"activePage === pages ? 'solid' : 'outline'\"  (click)=\"handleNext(activePage === pages ? true : false)\">\n        @if(activePage === pages) {\n          {{locale + '.submit' | translate}}\n        } @else {\n          {{locale + '.next' | translate}}\n          <ion-icon aria-hidden=\"true\" name=\"arrow-forward-outline\"></ion-icon>\n        }\n      </ion-button>\n    </div>\n  </div>\n</form>\n", styles: [".dcf-buttons-container{margin-top:1.8rem;margin-bottom:0}@media (min-width: 639px){.dcf-buttons-container.dcf-flex div:nth-child(2){display:flex;justify-content:flex-end}}@media (max-width: 638px){.dcf-buttons-container.dcf-flex div{width:100%}.dcf-buttons-container.dcf-flex ion-button{width:100%;margin-bottom:1rem}}.dcf-steped-form{padding:2rem 1rem}.dcf-page-steps{display:flex;justify-content:center;margin-bottom:2rem}.dcf-page-steps>div{justify-content:center;min-width:200px;max-width:200px;column-gap:.25em;display:flex}.dcf-page-steps>div>div{width:30px;text-align:center;border-bottom:solid var(--dcf-color-gray-3);box-sizing:border-box;border-width:3px;font-size:0px;font-weight:600}.dcf-page-steps>div>div.dcf-active{border-width:5px;font-size:1rem;color:var(--ion-color-gray-7);border-color:var(--ion-color-primary);line-height:1rem}.dcf-page-steps>div>div.dcf-passed{border-width:4px;font-size:.5rem;line-height:1.2rem;border-color:var(--dcf-color-gray-5);color:var(--ion-color-primary)}\n"], dependencies: [{ kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: IonSkeletonText, selector: "ion-skeleton-text", inputs: ["animated"] }, { kind: "component", type: IonText, selector: "ion-text", inputs: ["color", "mode"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "children", "model", "parent"], outputs: ["listenEvent"] }] }); }
+};
+SteppedFormComponent = __decorate([
+    Dynamic(),
+    __metadata("design:paramtypes", [])
+], SteppedFormComponent);
+export { SteppedFormComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SteppedFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-stepped-form', imports: [
+                        TranslatePipe,
+                        ReactiveFormsModule,
+                        IonSkeletonText,
+                        IonText,
+                        IonButton,
+                        IonIcon,
+                        ModelRendererComponent,
+                        ComponentRendererComponent
+                    ], standalone: true, template: "<form class=\"dcf-steped-form\" novalidate>\n  <div class=\"dcf-page-steps\">\n    <div>\n        @for(page of pagesArray; track $index;) {\n        <div [class.dcf-active]=\"activePage === $index + 1\" [class.dcf-passed]=\"($index + 1) < activePage\">{{ $index + 1 }}</div>\n      }\n    </div>\n  </div>\n  @if(formGroup) {\n    @for(child of activeChildren;  track $index) {\n      <ngx-decaf-component-renderer\n        [tag]=\"child?.tag\"\n        (listenEvent)=\"handleEvent($event)\"\n        [children]=\"child?.children || []\"\n        [globals]=\"{props: child.props}\"\n      />\n    }\n  } @else {\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n    <br />\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n  }\n\n  <div class=\"dcf-buttons-container dcf-grid dcf-grid-collapse dcf-flex dcf-flex-left\">\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button fill=\"clear\" (click)=\"handleBack()\" [disabled]=\"activePage <= 1\">\n        <ion-icon aria-hidden=\"true\" name=\"arrow-back-outline\"></ion-icon>\n          {{locale + '.previous' | translate}}\n      </ion-button>\n    </div>\n\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button [fill]=\"activePage === pages ? 'solid' : 'outline'\"  (click)=\"handleNext(activePage === pages ? true : false)\">\n        @if(activePage === pages) {\n          {{locale + '.submit' | translate}}\n        } @else {\n          {{locale + '.next' | translate}}\n          <ion-icon aria-hidden=\"true\" name=\"arrow-forward-outline\"></ion-icon>\n        }\n      </ion-button>\n    </div>\n  </div>\n</form>\n", styles: [".dcf-buttons-container{margin-top:1.8rem;margin-bottom:0}@media (min-width: 639px){.dcf-buttons-container.dcf-flex div:nth-child(2){display:flex;justify-content:flex-end}}@media (max-width: 638px){.dcf-buttons-container.dcf-flex div{width:100%}.dcf-buttons-container.dcf-flex ion-button{width:100%;margin-bottom:1rem}}.dcf-steped-form{padding:2rem 1rem}.dcf-page-steps{display:flex;justify-content:center;margin-bottom:2rem}.dcf-page-steps>div{justify-content:center;min-width:200px;max-width:200px;column-gap:.25em;display:flex}.dcf-page-steps>div>div{width:30px;text-align:center;border-bottom:solid var(--dcf-color-gray-3);box-sizing:border-box;border-width:3px;font-size:0px;font-weight:600}.dcf-page-steps>div>div.dcf-active{border-width:5px;font-size:1rem;color:var(--ion-color-gray-7);border-color:var(--ion-color-primary);line-height:1rem}.dcf-page-steps>div>div.dcf-passed{border-width:4px;font-size:.5rem;line-height:1.2rem;border-color:var(--dcf-color-gray-5);color:var(--ion-color-primary)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { locale: [{
+                type: Input
+            }], pages: [{
+                type: Input
+            }], operation: [{
+                type: Input
+            }], startPage: [{
+                type: Input
+            }], children: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }], submitEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepped-form.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/stepped-form/stepped-form.component.ts","../../../../../src/lib/components/stepped-form/stepped-form.component.html"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAqB,MAAM,EAAE,YAAY,EAAG,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAwB,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACzF,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EAAkB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAmB,OAAO,EAAE,cAAc,EAAY,cAAc,EAAE,MAAM,cAAc,CAAC;AAClG,OAAO,EAAE,0BAA0B,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAgB,KAAK,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;;;AAoB7C,IAAM,oBAAoB,GAA1B,MAAM,oBAAoB;IAqJ/B;;;;;;OAMG;IACH;QA3IA;;;;;;;;;WASG;QAEH,UAAK,GAAW,CAAC,CAAC;QAElB;;;;;;;;;WASG;QAEH,cAAS,GAAmB,aAAa,CAAC,MAAM,CAAC;QAEjD;;;;;;;;;WASG;QAEH,cAAS,GAAW,CAAC,CAAC;QA2BtB;;;;;;;;WAQG;QACH,mBAAc,GAAkC,SAAS,CAAC;QAE1D;;;;;;;;WAQG;QACH,oBAAe,GAA0B,SAAS,CAAC;QAEnD;;;;;;;;WAQG;QACH,eAAU,GAAW,CAAC,CAAC;QAEvB;;;;;;;;WAQG;QACH,eAAU,GAAsB,EAAE,CAAC;QAcnC;;;;;;;;WAQG;QAEH,gBAAW,GAAkC,IAAI,YAAY,EAAmB,CAAC;QAU/E,QAAQ,CAAC,EAAC,mBAAmB,EAAE,gBAAgB,EAAC,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ;QACN,IAAG,CAAC,IAAI,CAAC,MAAM;YACb,IAAI,CAAC,MAAM,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,CAAA;QACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;QAEjC,IAAI,CAAC,UAAU,GAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;YAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;YAC/C,IAAG,CAAC,GAAG,CAAC,IAAI,CAAC;gBACX,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACjB,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;YAC9B,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAc,CAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QACpC,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC3C,IAAG,CAAC,CAAC,CAAC,KAAK;oBACT,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBACf,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAClC,wBAAwB;gBACxB,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;gBACxD,OAAO,CAAC,CAAC;YACX,CAAC,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;OAMG;IACH,WAAW;QACT,IAAG,IAAI,CAAC,iBAAiB;YACvB,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,UAAU,CAAC,WAAoB,KAAK;QAClC,MAAM,OAAO,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,eAA4B,CAAC,CAAC;QACjF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;gBACtC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;aAAM,CAAC;YACP,IAAI,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,SAAsB,CAAC,CAAC,CAAC,CAAC;gBAC1G,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;oBACpB,IAAI;oBACJ,IAAI,EAAE,cAAc,CAAC,MAAM;iBAC5B,CAAC,CAAC;YACJ,CAAC;QACF,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU;QACR,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACK,mBAAmB,CAAC,IAAY;QACtC,IAAI,CAAC,eAAe,GAAI,IAAI,CAAC,SAAuB,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,CAAc,CAAC;QAC/E,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAChD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;YAC5E,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;+GArUU,oBAAoB;mGAApB,oBAAoB,uQChCjC,k0DA6CA,iiCDxBI,aAAa,iDACb,mBAAmB,oSACnB,eAAe,oFACf,OAAO,gFACP,SAAS,oPACT,OAAO,2JAEP,0BAA0B;;AAIjB,oBAAoB;IAjBhC,OAAO,EAAE;;GAiBG,oBAAoB,CAuUhC;;4FAvUY,oBAAoB;kBAhBhC,SAAS;+BACE,wBAAwB,WAGzB;wBACP,aAAa;wBACb,mBAAmB;wBACnB,eAAe;wBACf,OAAO;wBACP,SAAS;wBACT,OAAO;wBACP,sBAAsB;wBACtB,0BAA0B;qBAC3B,cACW,IAAI;wDAgBhB,MAAM;sBADL,KAAK;gBAeN,KAAK;sBADJ,KAAK;gBAcN,SAAS;sBADR,KAAK;gBAcN,SAAS;sBADR,KAAK;gBAcN,QAAQ;sBADP,KAAK;gBAaN,SAAS;sBADR,KAAK;gBAqEN,WAAW;sBADV,MAAM","sourcesContent":["import { Component, Input, OnInit, OnDestroy, Output, EventEmitter  } from '@angular/core';\nimport { FormArray, FormGroup, ReactiveFormsModule } from '@angular/forms';\nimport { IonButton, IonIcon, IonSkeletonText, IonText } from '@ionic/angular/standalone';\nimport { arrowForwardOutline, arrowBackOutline } from 'ionicons/icons';\nimport { addIcons } from 'ionicons';\nimport { UIModelMetadata} from '@decaf-ts/ui-decorators';\nimport { CrudOperations, OperationKeys } from '@decaf-ts/db-decorators';\nimport { BaseCustomEvent, Dynamic, EventConstants, KeyValue, NgxFormService } from '../../engine';\nimport { ComponentRendererComponent } from '../component-renderer/component-renderer.component';\nimport { ModelRendererComponent } from '../model-renderer/model-renderer.component';\nimport { Subscription, timer } from 'rxjs';\nimport { getLocaleContext } from '../../i18n/Loader';\nimport { TranslatePipe } from '@ngx-translate/core';\n\n\n@Dynamic()\n@Component({\n  selector: 'ngx-decaf-stepped-form',\n  templateUrl: './stepped-form.component.html',\n  styleUrls: ['./stepped-form.component.scss'],\n  imports: [\n    TranslatePipe,\n    ReactiveFormsModule,\n    IonSkeletonText,\n    IonText,\n    IonButton,\n    IonIcon,\n    ModelRendererComponent,\n    ComponentRendererComponent\n  ],\n  standalone: true,\n})\nexport class SteppedFormComponent implements OnInit, OnDestroy {\n\n    /**\n   * @description The locale to be used for translations.\n   * @summary Specifies the locale identifier to use when translating component text.\n   * This can be set explicitly via input property to override the automatically derived\n   * locale from the component name. The locale is typically a language code (e.g., 'en', 'fr')\n   * or a language-region code (e.g., 'en-US', 'fr-CA') that determines which translation\n   * set to use for the component's text content.\n   *\n   * @type {string}\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  locale!: string;\n\n\n  /**\n   * @description Number of pages in the stepped form.\n   * @summary Represents the total number of steps/pages in the multi-step form.\n   * This value is automatically calculated based on the page properties of the children\n   * or can be explicitly set. Each page represents a logical group of form fields.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  pages: number = 1;\n\n  /**\n   * @description The CRUD operation type for this form.\n   * @summary Defines the type of operation being performed (CREATE, READ, UPDATE, DELETE).\n   * This affects form behavior, validation rules, and field accessibility. For example,\n   * READ operations might disable form fields, while CREATE operations enable all fields.\n   *\n   * @type {CrudOperations}\n   * @default OperationKeys.CREATE\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  operation: CrudOperations = OperationKeys.CREATE;\n\n  /**\n   * @description The initial page to display when the form loads.\n   * @summary Specifies which page of the multi-step form should be shown first.\n   * This allows starting the form at any step, useful for scenarios like editing\n   * existing data where you might want to jump to a specific section.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  startPage: number = 1;\n\n  /**\n   * @description Array of UI model metadata for all form fields.\n   * @summary Contains the complete collection of UI model metadata that defines\n   * the structure, validation, and presentation of form fields across all pages.\n   * Each metadata object contains information about field type, validation rules,\n   * page assignment, and display properties.\n   *\n   * @type {UIModelMetadata[]}\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  children!: UIModelMetadata[];\n\n  /**\n   * @description Angular reactive FormGroup or FormArray for form state management.\n   * @summary The form instance that manages all form controls, validation, and form state.\n   * When using FormArray, each array element represents a page's FormGroup. When using\n   * FormGroup, it contains all form controls for the entire stepped form.\n   *\n   * @type {FormGroup | FormArray | undefined}\n   * @memberOf SteppedFormComponent\n   */\n  @Input()\n  formGroup!: FormGroup | FormArray | undefined;\n\n  /**\n   * @description Array of UI model metadata for the currently active page.\n   * @summary Contains only the UI model metadata for fields that should be displayed\n   * on the currently active page. This is a filtered subset of the children array,\n   * updated whenever the user navigates between pages.\n   *\n   * @type {UIModelMetadata[] | undefined}\n   * @memberOf SteppedFormComponent\n   */\n  activeChildren: UIModelMetadata[] | undefined = undefined;\n\n  /**\n   * @description FormGroup for the currently active page.\n   * @summary The FormGroup instance that manages form controls and validation\n   * for the current page only. This is extracted from the main formGroup\n   * when using FormArray structure.\n   *\n   * @type {FormGroup | undefined}\n   * @memberOf SteppedFormComponent\n   */\n  activeFormGroup: FormGroup | undefined = undefined;\n\n  /**\n   * @description The currently active page number.\n   * @summary Tracks which page of the multi-step form is currently being displayed.\n   * This property is updated as users navigate through the form steps using\n   * the next/back buttons or programmatic navigation.\n   *\n   * @type {number}\n   * @memberOf SteppedFormComponent\n   */\n  activePage: number = 1;\n\n  /**\n   * @description Array representing the structure of pages.\n   * @summary Contains metadata about each page, including page numbers and indices.\n   * This array is built during initialization to organize the form fields into\n   * logical pages and provide navigation structure.\n   *\n   * @type {UIModelMetadata[]}\n   * @memberOf SteppedFormComponent\n   */\n  pagesArray: UIModelMetadata[] = [];\n\n  /**\n   * @description Subscription for timer-based operations.\n   * @summary Manages the timer subscription used for asynchronous operations\n   * like updating active children after page transitions. This subscription\n   * is cleaned up in ngOnDestroy to prevent memory leaks.\n   *\n   * @private\n   * @type {Subscription}\n   * @memberOf SteppedFormComponent\n   */\n  private timerSubscription!: Subscription;\n\n  /**\n   * @description Event emitter for form submission.\n   * @summary Emits events when the form is submitted, typically on the last page\n   * when all validation passes. The emitted event contains the form data and\n   * event type information for parent components to handle.\n   *\n   * @type {EventEmitter<BaseCustomEvent>}\n   * @memberOf SteppedFormComponent\n   */\n  @Output()\n  submitEvent: EventEmitter<BaseCustomEvent> = new EventEmitter<BaseCustomEvent>();\n\n  /**\n   * @description Creates an instance of SteppedFormComponent.\n   * @summary Initializes a new SteppedFormComponent instance and registers the required\n   * Ionic icons for navigation buttons (forward and back arrows).\n   *\n   * @memberOf SteppedFormComponent\n   */\n  constructor() {\n    addIcons({arrowForwardOutline, arrowBackOutline});\n  }\n\n  /**\n   * @description Initializes the component after Angular first displays the data-bound properties.\n   * @summary Sets up the stepped form by organizing children into pages, calculating the total\n   * number of pages, and initializing the active page. This method processes the UI model metadata\n   * to create a logical page structure and ensures proper page assignments for all form fields.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant S as SteppedFormComponent\n   *   participant F as Form Service\n   *\n   *   A->>S: ngOnInit()\n   *   S->>S: Set activePage = startPage\n   *   S->>S: Process children into pagesArray\n   *   S->>S: Calculate total pages\n   *   S->>S: Assign page props to children\n   *   S->>S: getCurrentFormGroup(activePage)\n   *   S->>F: Extract FormGroup for active page\n   *   F-->>S: Return activeFormGroup\n   *\n   * @memberOf SteppedFormComponent\n   */\n  ngOnInit(): void  {\n    if(!this.locale)\n      this.locale = getLocaleContext(\"SteppedFormComponent\")\n    this.activePage = this.startPage;\n\n    this.pagesArray = (this.children.reduce((acc, curr, index) => {\n      const page = curr.props?.['page'] || index + 1;\n      if(!acc[page])\n        acc[page] = [];\n      acc[page].push({index: page});\n      return acc;\n    }, [] as KeyValue) as []).filter(Boolean);\n\n    this.pages = this.pagesArray.length;\n    this.children = [... this.children.map((c) => {\n      if(!c.props)\n        c.props = {};\n      const page = c.props['page'] || 1;\n      // prevent page overflow\n      c.props['page'] = page > this.pages ? this.pages : page;\n      return c;\n    })];\n    this.getCurrentFormGroup(this.activePage);\n  }\n\n  /**\n   * @description Cleanup method called when the component is destroyed.\n   * @summary Unsubscribes from any active timer subscriptions to prevent memory leaks.\n   * This is part of Angular's component lifecycle and ensures proper resource cleanup.\n   *\n   * @memberOf SteppedFormComponent\n   */\n  ngOnDestroy(): void {\n    if(this.timerSubscription)\n      this.timerSubscription.unsubscribe();\n  }\n\n  /**\n   * @description Handles navigation to the next page or form submission.\n   * @summary Validates the current page's form fields and either navigates to the next page\n   * or submits the entire form if on the last page. Form validation must pass before\n   * proceeding. On successful submission, emits a submit event with form data.\n   *\n   * @param {boolean} lastPage - Whether this is the last page of the form\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant S as SteppedFormComponent\n   *   participant F as Form Service\n   *   participant P as Parent Component\n   *\n   *   U->>S: Click Next/Submit\n   *   S->>F: validateFields(activeFormGroup)\n   *   F-->>S: Return validation result\n   *   alt Not last page and valid\n   *     S->>S: activePage++\n   *     S->>S: getCurrentFormGroup(activePage)\n   *   else Last page and valid\n   *     S->>F: getFormData(formGroup)\n   *     F-->>S: Return form data\n   *     S->>P: submitEvent.emit({data, name: SUBMIT})\n   *   end\n   *\n   * @memberOf SteppedFormComponent\n   */\n  handleNext(lastPage: boolean = false): void {\n    const isValid = NgxFormService.validateFields(this.activeFormGroup as FormGroup);\n    if (!lastPage) {\n      if (isValid) {\n        this.activePage = this.activePage + 1;\n        this.getCurrentFormGroup(this.activePage);\n      }\n    } else {\n     if (isValid) {\n      const data = Object.assign({}, ...Object.values(NgxFormService.getFormData(this.formGroup as FormGroup)));\n      this.submitEvent.emit({\n        data,\n        name: EventConstants.SUBMIT,\n      });\n     }\n    }\n  }\n\n  /**\n   * @description Handles navigation to the previous page.\n   * @summary Moves the user back to the previous page in the stepped form.\n   * This method decrements the active page number and updates the form\n   * group and children to display the previous page's content.\n   *\n   * @return {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant S as SteppedFormComponent\n   *\n   *   U->>S: Click Back\n   *   S->>S: activePage--\n   *   S->>S: getCurrentFormGroup(activePage)\n   *   Note over S: Update active form and children\n   *\n   * @memberOf SteppedFormComponent\n   */\n  handleBack(): void {\n    this.activePage = this.activePage - 1;\n    this.getCurrentFormGroup(this.activePage);\n  }\n\n  /**\n   * @description Updates the active form group and children for the specified page.\n   * @summary Extracts the FormGroup for the given page from the FormArray and filters\n   * the children to show only fields belonging to that page. Uses a timer to ensure\n   * proper Angular change detection when updating the activeChildren.\n   *\n   * @param {number} page - The page number to activate\n   * @return {void}\n   *\n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant S as SteppedFormComponent\n   *   participant F as FormArray\n   *   participant T as Timer\n   *\n   *   S->>F: Extract FormGroup at index (page - 1)\n   *   F-->>S: Return page FormGroup\n   *   S->>S: Set activeChildren = undefined\n   *   S->>T: timer(10).subscribe()\n   *   T-->>S: Filter children for active page\n   *   S->>S: Set activeChildren\n   *\n   * @memberOf SteppedFormComponent\n   */\n  private getCurrentFormGroup(page: number): void {\n    this.activeFormGroup = (this.formGroup as FormArray).at(page - 1) as FormGroup;\n    this.activeChildren = undefined;\n    this.timerSubscription = timer(10).subscribe(() => {\n      this.activeChildren = this.children.filter(c => c.props?.['page'] === page);\n      console.log(this.activeChildren);\n    });\n  }\n\n}\n","<form class=\"dcf-steped-form\" novalidate>\n  <div class=\"dcf-page-steps\">\n    <div>\n        @for(page of pagesArray; track $index;) {\n        <div [class.dcf-active]=\"activePage === $index + 1\" [class.dcf-passed]=\"($index + 1) < activePage\">{{ $index + 1 }}</div>\n      }\n    </div>\n  </div>\n  @if(formGroup) {\n    @for(child of activeChildren;  track $index) {\n      <ngx-decaf-component-renderer\n        [tag]=\"child?.tag\"\n        (listenEvent)=\"handleEvent($event)\"\n        [children]=\"child?.children || []\"\n        [globals]=\"{props: child.props}\"\n      />\n    }\n  } @else {\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n    <br />\n    <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n    <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n  }\n\n  <div class=\"dcf-buttons-container dcf-grid dcf-grid-collapse dcf-flex dcf-flex-left\">\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button fill=\"clear\" (click)=\"handleBack()\" [disabled]=\"activePage <= 1\">\n        <ion-icon aria-hidden=\"true\" name=\"arrow-back-outline\"></ion-icon>\n          {{locale + '.previous' | translate}}\n      </ion-button>\n    </div>\n\n    <div class=\"dcf-width-1-2@s\">\n      <ion-button [fill]=\"activePage === pages ? 'solid' : 'outline'\"  (click)=\"handleNext(activePage === pages ? true : false)\">\n        @if(activePage === pages) {\n          {{locale + '.submit' | translate}}\n        } @else {\n          {{locale + '.next' | translate}}\n          <ion-icon aria-hidden=\"true\" name=\"arrow-forward-outline\"></ion-icon>\n        }\n      </ion-button>\n    </div>\n  </div>\n</form>\n"]}