@decaf-ts/for-angular 0.0.12 → 0.0.14

package/esm2022/components/fieldset/fieldset.component.mjs

@@ -0,0 +1,225 @@
+import { __decorate } from "tslib";
+import { ChangeDetectorRef, Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, Input, ViewChild } from '@angular/core';
+import { Dynamic } from '../../engine';
+import { OperationKeys } from '@decaf-ts/db-decorators';
+import { ForAngularModule } from '../../for-angular.module';
+import { CollapsableDirective } from '../../directives/collapsable.directive';
+import { IonAccordion, IonAccordionGroup, IonItem } from '@ionic/angular/standalone';
+import * as i0 from "@angular/core";
+/**
+ * @description Dynamic fieldset component with collapsible accordion functionality.
+ * @summary This component provides a sophisticated fieldset container that automatically
+ * adapts its behavior based on CRUD operations. It integrates seamlessly with Ionic's
+ * accordion components to create expandable/collapsible sections for organizing form
+ * content and related information. The component intelligently determines its initial
+ * state based on the operation type, opening automatically for READ and DELETE operations
+ * while remaining closed for CREATE and UPDATE operations.
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage with automatic state management -->
+ * <ngx-decaf-fieldset
+ *   name="Personal Information"
+ *   [operation]="OperationKeys.READ"
+ *   target="_self">
+ *   <ion-input label="Name" placeholder="Enter name"></ion-input>
+ *   <ion-input label="Email" type="email" placeholder="Enter email"></ion-input>
+ * </ngx-decaf-fieldset>
+ *
+ * <!-- Advanced usage with custom operation -->
+ * <ngx-decaf-fieldset
+ *   name="Contact Details"
+ *   [operation]="currentOperation"
+ *   target="_blank">
+ *   <!-- Complex form fields -->
+ * </ngx-decaf-fieldset>
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User
+ *   participant F as FieldsetComponent
+ *   participant I as Ionic Accordion
+ *   participant D as DOM
+ *
+ *   F->>F: ngAfterViewInit()
+ *   alt operation is READ or DELETE
+ *     F->>F: Set isOpen = true
+ *     F->>D: Query accordion element
+ *     F->>I: Set value attribute to 'open'
+ *     F->>F: Trigger change detection
+ *   end
+ *   U->>I: Click accordion header
+ *   I->>F: handleChange(event)
+ *   F->>F: Update isOpen state
+ *   F->>I: Reflect new state
+ *
+ * @memberOf ForAngularModule
+ */
+let FieldsetComponent = class FieldsetComponent {
+    constructor() {
+        /**
+         * @description The display name or title of the fieldset section.
+         * @summary Sets the legend or header text that appears in the accordion header. This text
+         * provides a clear label for the collapsible section, helping users understand what content
+         * is contained within. The name is displayed prominently and serves as the clickable area
+         * for expanding/collapsing the fieldset.
+         *
+         * @type {string}
+         * @default 'Child'
+         * @memberOf FieldsetComponent
+         */
+        this.name = 'Child';
+        /**
+         * @description The current CRUD operation context.
+         * @summary Determines the component's initial behavior and state based on the current operation.
+         * This input is crucial for auto-state management: READ and DELETE operations automatically
+         * open the fieldset to show content, while CREATE and UPDATE operations keep it closed
+         * initially. This provides an intuitive user experience aligned with operation semantics.
+         *
+         * @type {OperationKeys}
+         * @default OperationKeys.READ
+         * @memberOf FieldsetComponent
+         */
+        this.operation = OperationKeys.READ;
+        /**
+         * @description Form target attribute for nested form submissions.
+         * @summary Specifies where to display the response after submitting forms contained within
+         * the fieldset. This attribute mirrors the HTML form target behavior, allowing control over
+         * whether form submissions open in the same window, new window, or specific frame. Useful
+         * for complex form workflows and multi-step processes.
+         *
+         * @type {HTMLFormTarget}
+         * @default '_self'
+         * @memberOf FieldsetComponent
+         */
+        this.target = '_self';
+        /**
+         * @description Current state of the accordion (expanded or collapsed).
+         * @summary Boolean flag that tracks whether the fieldset accordion is currently open or closed.
+         * This property is automatically managed based on user interactions and initial operation state.
+         * It serves as the single source of truth for the component's visibility state and is used
+         * to coordinate between user actions and programmatic state changes.
+         *
+         * @type {boolean}
+         * @default false
+         * @memberOf FieldsetComponent
+         */
+        this.isOpen = false;
+        /**
+         * @description Reference to CRUD operation constants for template usage.
+         * @summary Exposes the OperationKeys enum to the component template, enabling conditional
+         * rendering and behavior based on operation types. This protected readonly property ensures
+         * that template logic can access operation constants while maintaining encapsulation and
+         * preventing accidental modification of the enum values.
+         *
+         * @type {CrudOperations}
+         * @default OperationKeys.CREATE
+         * @memberOf FieldsetComponent
+         */
+        this.OperationKeys = OperationKeys.CREATE;
+        /**
+         * @description Angular change detection service.
+         * @summary Injected service that provides manual control over change detection cycles.
+         * This is essential for ensuring that programmatic DOM changes (like setting accordion
+         * attributes) are properly reflected in the component's state and trigger appropriate
+         * view updates when modifications occur outside the normal Angular change detection flow.
+         *
+         * @private
+         * @type {ChangeDetectorRef}
+         * @memberOf FieldsetComponent
+         */
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+    }
+    /**
+     * @description Initializes the component state after view and child components are rendered.
+     * @summary This lifecycle hook implements intelligent auto-state management based on the current
+     * CRUD operation. For READ and DELETE operations, the fieldset automatically opens to provide
+     * immediate access to information, while CREATE and UPDATE operations keep it closed to maintain
+     * a clean initial interface. The method directly manipulates the DOM to ensure proper accordion
+     * synchronization and triggers change detection to reflect the programmatic state changes.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant F as FieldsetComponent
+     *   participant D as DOM
+     *   participant C as ChangeDetector
+     *
+     *   A->>F: ngAfterViewInit()
+     *   alt operation is READ or DELETE
+     *     F->>F: Set isOpen = true
+     *     F->>D: Query ion-accordion-group element
+     *     alt accordion element exists
+     *       F->>D: Set value attribute to 'open'
+     *     end
+     *   end
+     *   F->>C: detectChanges()
+     *   C->>F: Update view with new state
+     *
+     * @returns {void}
+     * @memberOf FieldsetComponent
+     */
+    ngAfterViewInit() {
+        if (this.operation === OperationKeys.READ || this.operation === OperationKeys.DELETE) {
+            this.isOpen = true;
+            const accordionElement = this.component?.nativeElement.querySelector('ion-accordion-group');
+            if (accordionElement)
+                accordionElement.setAttribute('value', 'open');
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    /**
+     * @description Handles accordion state change events from user interactions.
+     * @summary Processes CustomEvent objects triggered when users expand or collapse the accordion.
+     * This method extracts the new state from the event details and updates the component's
+     * internal state accordingly. It specifically listens for ION-ACCORDION-GROUP events to
+     * ensure proper event source validation and prevent handling of unrelated events.
+     *
+     * @param {CustomEvent} event - The event object containing accordion state change details
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant I as Ion-Accordion
+     *   participant F as FieldsetComponent
+     *
+     *   U->>I: Click accordion header
+     *   I->>F: handleChange(CustomEvent)
+     *   F->>F: Extract target and detail from event
+     *   F->>F: Validate target is ION-ACCORDION-GROUP
+     *   alt valid target
+     *     F->>F: Update isOpen = !!value
+     *   end
+     *   F->>I: Reflect updated state
+     *
+     * @memberOf FieldsetComponent
+     */
+    handleChange(event) {
+        const { target, detail } = event;
+        const { value } = detail;
+        if (target.tagName === 'ION-ACCORDION-GROUP')
+            this.isOpen = !!value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldsetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FieldsetComponent, isStandalone: true, selector: "ngx-decaf-fieldset", inputs: { name: "name", operation: "operation", target: "target" }, viewQueries: [{ propertyName: "component", first: true, predicate: ["component"], descendants: true, read: ElementRef }], ngImport: i0, template: "<fieldset [class]=\"'dcf-fieldset ' + operation\" #component>\n  <ion-accordion-group (ionChange)=\"handleChange($event)\">\n    <ion-accordion value=\"open\">\n      <ion-item slot=\"header\" >\n        <legend>{{ name }}</legend>\n      </ion-item>\n      <div slot=\"content\" [attr.aria-hidden]=\"!isOpen\" decafCollapsable>\n        <ng-content></ng-content>\n      </div>\n    </ion-accordion>\n  </ion-accordion-group>\n</fieldset>\n", styles: [".dcf-fieldset{margin-bottom:1.8rem;padding-bottom:0;padding-top:1rem;border:1px solid var(--ion-color-gray-2);border-radius:8px}.dcf-fieldset ion-accordion-group{--border-color:red !important}.dcf-fieldset.read{margin-top:1.25rem}.dcf-fieldset ion-accordion.accordion-collapsing,.dcf-fieldset ion-accordion.accordion-collapsed{margin-bottom:1rem}.dcf-fieldset ion-accordion ion-item[slot=header]{--border-color: transparent;--border-radius: 6px;--inner-border-width: 0;--padding-start: 12px}.dcf-fieldset ion-accordion ion-item[slot=header] legend{font-weight:600;font-size:1rem;color:#333;margin:0}.dcf-fieldset ion-accordion [slot=content]{padding-top:1rem!important;padding-inline:.75rem;background-color:#fff}\n"], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "component", type: IonAccordionGroup, selector: "ion-accordion-group", inputs: ["animated", "disabled", "expand", "mode", "multiple", "readonly", "value"] }, { kind: "component", type: IonAccordion, selector: "ion-accordion", inputs: ["disabled", "mode", "readonly", "toggleIcon", "toggleIconSlot", "value"] }, { kind: "component", type: IonItem, selector: "ion-item", inputs: ["button", "color", "detail", "detailIcon", "disabled", "download", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { kind: "directive", type: CollapsableDirective, selector: "[decafCollapsable]" }] }); }
+};
+FieldsetComponent = __decorate([
+    Dynamic()
+], FieldsetComponent);
+export { FieldsetComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldsetComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'ngx-decaf-fieldset', schemas: [CUSTOM_ELEMENTS_SCHEMA], imports: [ForAngularModule, IonAccordionGroup, IonAccordion, IonItem, CollapsableDirective], template: "<fieldset [class]=\"'dcf-fieldset ' + operation\" #component>\n  <ion-accordion-group (ionChange)=\"handleChange($event)\">\n    <ion-accordion value=\"open\">\n      <ion-item slot=\"header\" >\n        <legend>{{ name }}</legend>\n      </ion-item>\n      <div slot=\"content\" [attr.aria-hidden]=\"!isOpen\" decafCollapsable>\n        <ng-content></ng-content>\n      </div>\n    </ion-accordion>\n  </ion-accordion-group>\n</fieldset>\n", styles: [".dcf-fieldset{margin-bottom:1.8rem;padding-bottom:0;padding-top:1rem;border:1px solid var(--ion-color-gray-2);border-radius:8px}.dcf-fieldset ion-accordion-group{--border-color:red !important}.dcf-fieldset.read{margin-top:1.25rem}.dcf-fieldset ion-accordion.accordion-collapsing,.dcf-fieldset ion-accordion.accordion-collapsed{margin-bottom:1rem}.dcf-fieldset ion-accordion ion-item[slot=header]{--border-color: transparent;--border-radius: 6px;--inner-border-width: 0;--padding-start: 12px}.dcf-fieldset ion-accordion ion-item[slot=header] legend{font-weight:600;font-size:1rem;color:#333;margin:0}.dcf-fieldset ion-accordion [slot=content]{padding-top:1rem!important;padding-inline:.75rem;background-color:#fff}\n"] }]
+        }], propDecorators: { component: [{
+                type: ViewChild,
+                args: ['component', { static: false, read: ElementRef }]
+            }], name: [{
+                type: Input
+            }], operation: [{
+                type: Input
+            }], target: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fieldset.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/fieldset/fieldset.component.ts","../../../../../src/lib/components/fieldset/fieldset.component.html"],"names":[],"mappings":";AACA,OAAO,EAAiB,iBAAiB,EAAE,SAAS,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1I,OAAO,EAAE,OAAO,EAAkB,MAAM,cAAc,CAAC;AACvD,OAAO,EAAkB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAUI,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAAvB;QAeL;;;;;;;;;;WAUG;QAEH,SAAI,GAAW,OAAO,CAAC;QAEvB;;;;;;;;;;WAUG;QAEH,cAAS,GAAkB,aAAa,CAAC,IAAI,CAAC;QAE9C;;;;;;;;;;WAUG;QAEH,WAAM,GAAmB,OAAO,CAAC;QAEjC;;;;;;;;;;WAUG;QACH,WAAM,GAAY,KAAK,CAAC;QAExB;;;;;;;;;;WAUG;QACgB,kBAAa,GAAmB,aAAa,CAAC,MAAM,CAAC;QAExE;;;;;;;;;;WAUG;QACK,sBAAiB,GAAsB,MAAM,CAAC,iBAAiB,CAAC,CAAC;KA0E1E;IAxEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eAAe;QACb,IAAI,IAAI,CAAC,SAAS,KAAK,aAAa,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,aAAa,CAAC,MAAM,EAAE,CAAC;YACrF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;YAC5F,IAAG,gBAAgB;gBACjB,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACnD,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,YAAY,CAAC,KAAkB;QAC7B,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QACjC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QACzB,IAAK,MAAuC,CAAC,OAAO,KAAK,qBAAqB;YAC5E,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;IAC1B,CAAC;+GAvKU,iBAAiB;mGAAjB,iBAAiB,qOAYmB,UAAU,6BC/E3D,0bAYA,owBDqDY,gBAAgB,+BAAE,iBAAiB,qJAAE,YAAY,6IAAE,OAAO,0NAAE,oBAAoB;;AAE/E,iBAAiB;IAT7B,OAAO,EAAE;GASG,iBAAiB,CAwK7B;;4FAxKY,iBAAiB;kBAR7B,SAAS;iCACI,IAAI,YACN,oBAAoB,WAGrB,CAAC,sBAAsB,CAAC,WACxB,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,YAAY,EAAE,OAAO,EAAE,oBAAoB,CAAC;8BAe3F,SAAS;sBADR,SAAS;uBAAC,WAAW,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;gBAe3D,IAAI;sBADH,KAAK;gBAeN,SAAS;sBADR,KAAK;gBAeN,MAAM;sBADL,KAAK","sourcesContent":["\nimport { AfterViewInit, ChangeDetectorRef, Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, Input, ViewChild } from '@angular/core';\nimport { Dynamic, HTMLFormTarget } from '../../engine';\nimport { CrudOperations, OperationKeys } from '@decaf-ts/db-decorators';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { CollapsableDirective } from '../../directives/collapsable.directive';\nimport { IonAccordion, IonAccordionGroup, IonItem } from '@ionic/angular/standalone';\n\n/**\n * @description Dynamic fieldset component with collapsible accordion functionality.\n * @summary This component provides a sophisticated fieldset container that automatically\n * adapts its behavior based on CRUD operations. It integrates seamlessly with Ionic's\n * accordion components to create expandable/collapsible sections for organizing form\n * content and related information. The component intelligently determines its initial\n * state based on the operation type, opening automatically for READ and DELETE operations\n * while remaining closed for CREATE and UPDATE operations.\n *\n * @example\n * ```html\n * <!-- Basic usage with automatic state management -->\n * <ngx-decaf-fieldset\n *   name=\"Personal Information\"\n *   [operation]=\"OperationKeys.READ\"\n *   target=\"_self\">\n *   <ion-input label=\"Name\" placeholder=\"Enter name\"></ion-input>\n *   <ion-input label=\"Email\" type=\"email\" placeholder=\"Enter email\"></ion-input>\n * </ngx-decaf-fieldset>\n *\n * <!-- Advanced usage with custom operation -->\n * <ngx-decaf-fieldset\n *   name=\"Contact Details\"\n *   [operation]=\"currentOperation\"\n *   target=\"_blank\">\n *   <!-- Complex form fields -->\n * </ngx-decaf-fieldset>\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant U as User\n *   participant F as FieldsetComponent\n *   participant I as Ionic Accordion\n *   participant D as DOM\n *\n *   F->>F: ngAfterViewInit()\n *   alt operation is READ or DELETE\n *     F->>F: Set isOpen = true\n *     F->>D: Query accordion element\n *     F->>I: Set value attribute to 'open'\n *     F->>F: Trigger change detection\n *   end\n *   U->>I: Click accordion header\n *   I->>F: handleChange(event)\n *   F->>F: Update isOpen state\n *   F->>I: Reflect new state\n *\n * @memberOf ForAngularModule\n */\n@Dynamic()\n@Component({\n  standalone: true,\n  selector: 'ngx-decaf-fieldset',\n  templateUrl: './fieldset.component.html',\n  styleUrls: ['./fieldset.component.scss'],\n  schemas: [CUSTOM_ELEMENTS_SCHEMA],\n  imports: [ForAngularModule, IonAccordionGroup, IonAccordion, IonItem, CollapsableDirective],\n})\nexport class FieldsetComponent implements AfterViewInit {\n\n  /**\n   * @description Reference to the component's native DOM element.\n   * @summary ViewChild reference that provides direct access to the component's root DOM element.\n   * This is essential for manipulating the Ionic accordion group after view initialization,\n   * particularly for setting the initial open state programmatically. The reference is used\n   * to query and modify accordion attributes that control the component's expanded state.\n   *\n   * @type {ElementRef}\n   * @memberOf FieldsetComponent\n   */\n  @ViewChild('component', { static: false, read: ElementRef })\n  component!: ElementRef;\n\n  /**\n   * @description The display name or title of the fieldset section.\n   * @summary Sets the legend or header text that appears in the accordion header. This text\n   * provides a clear label for the collapsible section, helping users understand what content\n   * is contained within. The name is displayed prominently and serves as the clickable area\n   * for expanding/collapsing the fieldset.\n   *\n   * @type {string}\n   * @default 'Child'\n   * @memberOf FieldsetComponent\n   */\n  @Input()\n  name: string = 'Child';\n\n  /**\n   * @description The current CRUD operation context.\n   * @summary Determines the component's initial behavior and state based on the current operation.\n   * This input is crucial for auto-state management: READ and DELETE operations automatically\n   * open the fieldset to show content, while CREATE and UPDATE operations keep it closed\n   * initially. This provides an intuitive user experience aligned with operation semantics.\n   *\n   * @type {OperationKeys}\n   * @default OperationKeys.READ\n   * @memberOf FieldsetComponent\n   */\n  @Input()\n  operation: OperationKeys = OperationKeys.READ;\n\n  /**\n   * @description Form target attribute for nested form submissions.\n   * @summary Specifies where to display the response after submitting forms contained within\n   * the fieldset. This attribute mirrors the HTML form target behavior, allowing control over\n   * whether form submissions open in the same window, new window, or specific frame. Useful\n   * for complex form workflows and multi-step processes.\n   *\n   * @type {HTMLFormTarget}\n   * @default '_self'\n   * @memberOf FieldsetComponent\n   */\n  @Input()\n  target: HTMLFormTarget = '_self';\n\n  /**\n   * @description Current state of the accordion (expanded or collapsed).\n   * @summary Boolean flag that tracks whether the fieldset accordion is currently open or closed.\n   * This property is automatically managed based on user interactions and initial operation state.\n   * It serves as the single source of truth for the component's visibility state and is used\n   * to coordinate between user actions and programmatic state changes.\n   *\n   * @type {boolean}\n   * @default false\n   * @memberOf FieldsetComponent\n   */\n  isOpen: boolean = false;\n\n  /**\n   * @description Reference to CRUD operation constants for template usage.\n   * @summary Exposes the OperationKeys enum to the component template, enabling conditional\n   * rendering and behavior based on operation types. This protected readonly property ensures\n   * that template logic can access operation constants while maintaining encapsulation and\n   * preventing accidental modification of the enum values.\n   *\n   * @type {CrudOperations}\n   * @default OperationKeys.CREATE\n   * @memberOf FieldsetComponent\n   */\n  protected readonly OperationKeys: CrudOperations = OperationKeys.CREATE;\n\n  /**\n   * @description Angular change detection service.\n   * @summary Injected service that provides manual control over change detection cycles.\n   * This is essential for ensuring that programmatic DOM changes (like setting accordion\n   * attributes) are properly reflected in the component's state and trigger appropriate\n   * view updates when modifications occur outside the normal Angular change detection flow.\n   *\n   * @private\n   * @type {ChangeDetectorRef}\n   * @memberOf FieldsetComponent\n   */\n  private changeDetectorRef: ChangeDetectorRef = inject(ChangeDetectorRef);\n\n  /**\n   * @description Initializes the component state after view and child components are rendered.\n   * @summary This lifecycle hook implements intelligent auto-state management based on the current\n   * CRUD operation. For READ and DELETE operations, the fieldset automatically opens to provide\n   * immediate access to information, while CREATE and UPDATE operations keep it closed to maintain\n   * a clean initial interface. The method directly manipulates the DOM to ensure proper accordion\n   * synchronization and triggers change detection to reflect the programmatic state changes.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant F as FieldsetComponent\n   *   participant D as DOM\n   *   participant C as ChangeDetector\n   *\n   *   A->>F: ngAfterViewInit()\n   *   alt operation is READ or DELETE\n   *     F->>F: Set isOpen = true\n   *     F->>D: Query ion-accordion-group element\n   *     alt accordion element exists\n   *       F->>D: Set value attribute to 'open'\n   *     end\n   *   end\n   *   F->>C: detectChanges()\n   *   C->>F: Update view with new state\n   *\n   * @returns {void}\n   * @memberOf FieldsetComponent\n   */\n  ngAfterViewInit(): void {\n    if (this.operation === OperationKeys.READ || this.operation === OperationKeys.DELETE) {\n      this.isOpen = true;\n      const accordionElement = this.component?.nativeElement.querySelector('ion-accordion-group');\n      if(accordionElement)\n        accordionElement.setAttribute('value', 'open');\n    }\n    this.changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * @description Handles accordion state change events from user interactions.\n   * @summary Processes CustomEvent objects triggered when users expand or collapse the accordion.\n   * This method extracts the new state from the event details and updates the component's\n   * internal state accordingly. It specifically listens for ION-ACCORDION-GROUP events to\n   * ensure proper event source validation and prevent handling of unrelated events.\n   *\n   * @param {CustomEvent} event - The event object containing accordion state change details\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant I as Ion-Accordion\n   *   participant F as FieldsetComponent\n   *\n   *   U->>I: Click accordion header\n   *   I->>F: handleChange(CustomEvent)\n   *   F->>F: Extract target and detail from event\n   *   F->>F: Validate target is ION-ACCORDION-GROUP\n   *   alt valid target\n   *     F->>F: Update isOpen = !!value\n   *   end\n   *   F->>I: Reflect updated state\n   *\n   * @memberOf FieldsetComponent\n   */\n  handleChange(event: CustomEvent): void {\n    const { target, detail } = event;\n    const { value } = detail;\n    if ((target as HTMLIonAccordionGroupElement).tagName === 'ION-ACCORDION-GROUP')\n      this.isOpen = !!value;\n  }\n}\n","<fieldset [class]=\"'dcf-fieldset ' + operation\" #component>\n  <ion-accordion-group (ionChange)=\"handleChange($event)\">\n    <ion-accordion value=\"open\">\n      <ion-item slot=\"header\" >\n        <legend>{{ name }}</legend>\n      </ion-item>\n      <div slot=\"content\" [attr.aria-hidden]=\"!isOpen\" decafCollapsable>\n        <ng-content></ng-content>\n      </div>\n    </ion-accordion>\n  </ion-accordion-group>\n</fieldset>\n"]}