@ng-formworks/material 17.5.6 → 17.5.8

package/esm2022/lib/material-design-framework.module.mjs

@@ -1,3 +1,4 @@
+import { DragDropModule } from '@angular/cdk/drag-drop';
 import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
@@ -24,6 +25,7 @@ import { MatToolbarModule } from '@angular/material/toolbar';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import { Framework, FrameworkLibraryService, JsonSchemaFormModule, JsonSchemaFormService, WidgetLibraryModule, WidgetLibraryService } from '@ng-formworks/core';
 import { CssFrameworkModule } from '@ng-formworks/cssframework';
+import { SortablejsModule } from 'nxt-sortablejs';
 import { MaterialDesignFramework } from './material-design.framework';
 import { MATERIAL_FRAMEWORK_COMPONENTS } from './widgets/public_api';
 import * as i0 from "@angular/core";
@@ -47,6 +49,7 @@ import * as i17 from "./widgets/material-stepper.component";
 import * as i18 from "./widgets/material-tabs.component";
 import * as i19 from "./widgets/material-textarea.component";
 import * as i20 from "./material-design-framework.component";
+import * as i21 from "nxt-sortablejs";
 /**
  * unused @angular/material modules:
  * MatDialogModule, MatGridListModule, MatListModule, MatMenuModule,
@@ -61,6 +64,7 @@ export const ANGULAR_MATERIAL_MODULES = [
     MatRadioModule, MatSelectModule, MatSliderModule, MatSlideToggleModule,
     MatStepperModule, MatTabsModule, MatTooltipModule,
     MatToolbarModule, MatMenuModule, MatToolbarModule,
+    DragDropModule
 ];
 export class MaterialDesignFrameworkModule {
     constructor() {
@@ -73,9 +77,10 @@ export class MaterialDesignFrameworkModule {
             MatFormFieldModule, MatIconModule, MatInputModule, MatNativeDateModule,
             MatRadioModule, MatSelectModule, MatSliderModule, MatSlideToggleModule,
             MatStepperModule, MatTabsModule, MatTooltipModule,
-            MatToolbarModule, MatMenuModule, MatToolbarModule, WidgetLibraryModule,
+            MatToolbarModule, MatMenuModule, MatToolbarModule,
+            DragDropModule, WidgetLibraryModule,
             JsonSchemaFormModule,
-            CssFrameworkModule], exports: [JsonSchemaFormModule, i1.FlexLayoutRootComponent, i2.FlexLayoutSectionComponent, i3.MaterialAddReferenceComponent, i4.MaterialOneOfComponent, i5.MaterialButtonComponent, i6.MaterialButtonGroupComponent, i7.MaterialCheckboxComponent, i8.MaterialCheckboxesComponent, i9.MaterialChipListComponent, i10.MaterialDatepickerComponent, i11.MaterialFileComponent, i12.MaterialInputComponent, i13.MaterialNumberComponent, i14.MaterialRadiosComponent, i15.MaterialSelectComponent, i16.MaterialSliderComponent, i17.MaterialStepperComponent, i18.MaterialTabsComponent, i19.MaterialTextareaComponent, i20.MaterialDesignFrameworkComponent] }); }
+            CssFrameworkModule, i21.SortablejsModule], exports: [JsonSchemaFormModule, i1.FlexLayoutRootComponent, i2.FlexLayoutSectionComponent, i3.MaterialAddReferenceComponent, i4.MaterialOneOfComponent, i5.MaterialButtonComponent, i6.MaterialButtonGroupComponent, i7.MaterialCheckboxComponent, i8.MaterialCheckboxesComponent, i9.MaterialChipListComponent, i10.MaterialDatepickerComponent, i11.MaterialFileComponent, i12.MaterialInputComponent, i13.MaterialNumberComponent, i14.MaterialRadiosComponent, i15.MaterialSelectComponent, i16.MaterialSliderComponent, i17.MaterialStepperComponent, i18.MaterialTabsComponent, i19.MaterialTextareaComponent, i20.MaterialDesignFrameworkComponent] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MaterialDesignFrameworkModule, providers: [
             JsonSchemaFormService,
             FrameworkLibraryService,
@@ -85,7 +90,13 @@ export class MaterialDesignFrameworkModule {
             FormsModule,
             ReactiveFormsModule, ANGULAR_MATERIAL_MODULES, WidgetLibraryModule,
             JsonSchemaFormModule,
-            CssFrameworkModule, JsonSchemaFormModule] }); }
+            CssFrameworkModule,
+            SortablejsModule.forRoot({
+                //disabled:false,
+                //draggable:".draggableitem",//">:not(.nonsort)",//">.draggable-item",//":not(.nonsort)",//">*",//":not(.nonsort)",//":not(.non-draggable)",
+                filter: ".sortable-filter",
+                preventOnFilter: false //needed for input range elements slider do still work
+            }), JsonSchemaFormModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MaterialDesignFrameworkModule, decorators: [{
             type: NgModule,
@@ -97,7 +108,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         ...ANGULAR_MATERIAL_MODULES,
                         WidgetLibraryModule,
                         JsonSchemaFormModule,
-                        CssFrameworkModule
+                        CssFrameworkModule,
+                        SortablejsModule.forRoot({
+                            //disabled:false,
+                            //draggable:".draggableitem",//">:not(.nonsort)",//">.draggable-item",//":not(.nonsort)",//">*",//":not(.nonsort)",//":not(.non-draggable)",
+                            filter: ".sortable-filter",
+                            preventOnFilter: false //needed for input range elements slider do still work
+                        })
                     ],
                     declarations: [
                         ...MATERIAL_FRAMEWORK_COMPONENTS,
@@ -114,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     ]
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material-design-framework.module.js","sourceRoot":"","sources":["../../../../../projects/ng-formworks-material/src/lib/material-design-framework.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EACH,SAAS,EACT,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EAAE,oBAAoB,EAC5C,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;AAGrE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,qBAAqB,EAAE,eAAe,EAAE,qBAAqB,EAAE,aAAa;IAC5E,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,kBAAkB;IAC1E,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB;IACtE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,oBAAoB;IACtE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB;IACjD,gBAAgB,EAAE,aAAa,EAAE,gBAAgB;CAClD,CAAC;AA0BF,MAAM,OAAO,6BAA6B;IACxC;IAEA,CAAC;+GAHU,6BAA6B;gHAA7B,6BAA6B,unBAtBlC,YAAY;YACZ,WAAW;YACX,mBAAmB,EAZzB,qBAAqB,EAAE,eAAe,EAAE,qBAAqB,EAAE,aAAa;YAC5E,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,kBAAkB;YAC1E,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB;YACtE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,oBAAoB;YACtE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB;YACjD,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,EAS3C,mBAAmB;YACnB,oBAAoB;YACpB,kBAAkB,aAMlB,oBAAoB;gHAUf,6BAA6B,aAP3B;YACP,qBAAqB;YACrB,uBAAuB;YACvB,oBAAoB;YACpB,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,uBAAuB,EAAE,KAAK,EAAE,IAAI,EAAE;SACzE,YApBG,YAAY;YACZ,WAAW;YACX,mBAAmB,EAChB,wBAAwB,EAC3B,mBAAmB;YACnB,oBAAoB;YACpB,kBAAkB,EAMlB,oBAAoB;;4FAUf,6BAA6B;kBAxBzC,QAAQ;mBAAC;oBACN,OAAO,EAAE;wBACL,YAAY;wBACZ,WAAW;wBACX,mBAAmB;wBACnB,GAAG,wBAAwB;wBAC3B,mBAAmB;wBACnB,oBAAoB;wBACpB,kBAAkB;qBACrB;oBACD,YAAY,EAAE;wBACV,GAAG,6BAA6B;qBACnC;oBACD,OAAO,EAAE;wBACL,oBAAoB;wBACpB,GAAG,6BAA6B;qBACnC;oBACD,SAAS,EAAE;wBACP,qBAAqB;wBACrB,uBAAuB;wBACvB,oBAAoB;wBACpB,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,uBAAuB,EAAE,KAAK,EAAE,IAAI,EAAE;qBACzE;iBACJ","sourcesContent":["import { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { MatNativeDateModule } from '@angular/material/core';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatExpansionModule } from '@angular/material/expansion';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatMenuModule } from '@angular/material/menu';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatSliderModule } from '@angular/material/slider';\r\nimport { MatStepperModule } from '@angular/material/stepper';\r\nimport { MatTabsModule } from '@angular/material/tabs';\r\nimport { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport {\r\n    Framework,\r\n    FrameworkLibraryService,\r\n    JsonSchemaFormModule,\r\n    JsonSchemaFormService,\r\n    WidgetLibraryModule, WidgetLibraryService\r\n} from '@ng-formworks/core';\r\nimport { CssFrameworkModule } from '@ng-formworks/cssframework';\r\nimport { MaterialDesignFramework } from './material-design.framework';\r\nimport { MATERIAL_FRAMEWORK_COMPONENTS } from './widgets/public_api';\r\n\r\n\r\n/**\r\n * unused @angular/material modules:\r\n * MatDialogModule, MatGridListModule, MatListModule, MatMenuModule,\r\n * MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule,\r\n * MatSidenavModule, MatSnackBarModule, MatSortModule, MatTableModule,\r\n * ,\r\n */\r\nexport const ANGULAR_MATERIAL_MODULES = [\r\n  MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule,\r\n  MatCheckboxModule, MatChipsModule, MatDatepickerModule, MatExpansionModule,\r\n  MatFormFieldModule, MatIconModule, MatInputModule, MatNativeDateModule,\r\n  MatRadioModule, MatSelectModule, MatSliderModule, MatSlideToggleModule,\r\n  MatStepperModule, MatTabsModule, MatTooltipModule,\r\n  MatToolbarModule, MatMenuModule, MatToolbarModule,\r\n];\r\n\r\n@NgModule({\r\n    imports: [\r\n        CommonModule,\r\n        FormsModule,\r\n        ReactiveFormsModule,\r\n        ...ANGULAR_MATERIAL_MODULES,\r\n        WidgetLibraryModule,\r\n        JsonSchemaFormModule,\r\n        CssFrameworkModule\r\n    ],\r\n    declarations: [\r\n        ...MATERIAL_FRAMEWORK_COMPONENTS,\r\n    ],\r\n    exports: [\r\n        JsonSchemaFormModule,\r\n        ...MATERIAL_FRAMEWORK_COMPONENTS,\r\n    ],\r\n    providers: [\r\n        JsonSchemaFormService,\r\n        FrameworkLibraryService,\r\n        WidgetLibraryService,\r\n        { provide: Framework, useClass: MaterialDesignFramework, multi: true },\r\n    ]\r\n})\r\nexport class MaterialDesignFrameworkModule {\r\n  constructor() {\r\n\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material-design-framework.module.js","sourceRoot":"","sources":["../../../../../projects/ng-formworks-material/src/lib/material-design-framework.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { DragDropModule } from '@angular/cdk/drag-drop';\r\nimport { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { MatNativeDateModule } from '@angular/material/core';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatExpansionModule } from '@angular/material/expansion';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatMenuModule } from '@angular/material/menu';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatSliderModule } from '@angular/material/slider';\r\nimport { MatStepperModule } from '@angular/material/stepper';\r\nimport { MatTabsModule } from '@angular/material/tabs';\r\nimport { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\n\r\nimport {\r\n    Framework,\r\n    FrameworkLibraryService,\r\n    JsonSchemaFormModule,\r\n    JsonSchemaFormService,\r\n    WidgetLibraryModule, WidgetLibraryService\r\n} from '@ng-formworks/core';\r\nimport { CssFrameworkModule } from '@ng-formworks/cssframework';\r\nimport { SortablejsModule } from 'nxt-sortablejs';\r\nimport { MaterialDesignFramework } from './material-design.framework';\r\nimport { MATERIAL_FRAMEWORK_COMPONENTS } from './widgets/public_api';\r\n\r\n\r\n/**\r\n * unused @angular/material modules:\r\n * MatDialogModule, MatGridListModule, MatListModule, MatMenuModule,\r\n * MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule,\r\n * MatSidenavModule, MatSnackBarModule, MatSortModule, MatTableModule,\r\n * ,\r\n */\r\nexport const ANGULAR_MATERIAL_MODULES = [\r\n  MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule,\r\n  MatCheckboxModule, MatChipsModule, MatDatepickerModule, MatExpansionModule,\r\n  MatFormFieldModule, MatIconModule, MatInputModule, MatNativeDateModule,\r\n  MatRadioModule, MatSelectModule, MatSliderModule, MatSlideToggleModule,\r\n  MatStepperModule, MatTabsModule, MatTooltipModule,\r\n  MatToolbarModule, MatMenuModule, MatToolbarModule,\r\n  DragDropModule\r\n];\r\n\r\n@NgModule({\r\n    imports: [\r\n        CommonModule,\r\n        FormsModule,\r\n        ReactiveFormsModule,\r\n        ...ANGULAR_MATERIAL_MODULES,\r\n        WidgetLibraryModule,\r\n        JsonSchemaFormModule,\r\n        CssFrameworkModule,\r\n                SortablejsModule.forRoot({\r\n                //disabled:false,\r\n                //draggable:\".draggableitem\",//\">:not(.nonsort)\",//\">.draggable-item\",//\":not(.nonsort)\",//\">*\",//\":not(.nonsort)\",//\":not(.non-draggable)\",\r\n                filter:\".sortable-filter\",//needed to disable dragging on input range elements, class needs to be added to the element or its parent\r\n                preventOnFilter: false//needed for input range elements slider do still work\r\n        \r\n              })\r\n    ],\r\n    declarations: [\r\n        ...MATERIAL_FRAMEWORK_COMPONENTS,\r\n    ],\r\n    exports: [\r\n        JsonSchemaFormModule,\r\n        ...MATERIAL_FRAMEWORK_COMPONENTS,\r\n    ],\r\n    providers: [\r\n        JsonSchemaFormService,\r\n        FrameworkLibraryService,\r\n        WidgetLibraryService,\r\n        { provide: Framework, useClass: MaterialDesignFramework, multi: true },\r\n    ]\r\n})\r\nexport class MaterialDesignFrameworkModule {\r\n  constructor() {\r\n\r\n  }\r\n}\r\n"]}

package/esm2022/lib/widgets/flex-layout-root.component.mjs

@@ -1,8 +1,9 @@
-import { ChangeDetectionStrategy, Component, input, inject } from '@angular/core';
+import { ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
 import { JsonSchemaFormService } from '@ng-formworks/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
-import * as i2 from "@ng-formworks/core";
+import * as i2 from "@angular/cdk/drag-drop";
+import * as i3 from "@ng-formworks/core";
 export class FlexLayoutRootComponent {
     constructor() {
         this.jsf = inject(JsonSchemaFormService);
@@ -10,10 +11,39 @@ export class FlexLayoutRootComponent {
         this.layoutIndex = input(undefined);
         this.layout = input(undefined);
         this.isFlexItem = input(false);
+        this.sortableConfig = {
+            filter: ".sortable-filter",
+            preventOnFilter: false,
+            onEnd: (/**Event*/ evt) => {
+            }
+        };
+    }
+    ngOnInit() {
+        console.log("debug FlexLayoutRootComponent:" + this);
     }
     removeItem(item) {
         this.jsf.removeItem(item);
     }
+    sortableInit(sortable) {
+        this.sortableObj = sortable;
+    }
+    drop(event) {
+        // most likely why this event is used is to get the dragging element's current index
+        // same properties as onEnd
+        //console.log(`sortablejs event:${evt}`);
+        let srcInd = event.previousIndex;
+        let trgInd = event.currentIndex;
+        let layoutItem = this.layout()[trgInd];
+        let dataInd = layoutItem?.arrayItem ? (this.dataIndex() || []).concat(trgInd) : (this.dataIndex() || []);
+        let layoutInd = (this.layoutIndex() || []).concat(trgInd);
+        let itemCtx = {
+            dataIndex: () => { return dataInd; },
+            layoutIndex: () => { return layoutInd; },
+            layoutNode: () => { return layoutItem; },
+        };
+        //must set moveLayout to false as nxtSortable already moves it
+        this.jsf.moveArrayItem(itemCtx, srcInd, trgInd, true);
+    }
     // Set attributes for flexbox child
     // (container attributes are set in flex-layout-section.component)
     getFlexAttribute(node, attribute) {
@@ -26,46 +56,65 @@ export class FlexLayoutRootComponent {
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FlexLayoutRootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: FlexLayoutRootComponent, selector: "flex-layout-root-widget", inputs: { dataIndex: { classPropertyName: "dataIndex", publicName: "dataIndex", isSignal: true, isRequired: false, transformFunction: null }, layoutIndex: { classPropertyName: "layoutIndex", publicName: "layoutIndex", isSignal: true, isRequired: false, transformFunction: null }, layout: { classPropertyName: "layout", publicName: "layout", isSignal: true, isRequired: false, transformFunction: null }, isFlexItem: { classPropertyName: "isFlexItem", publicName: "isFlexItem", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
-    <div *ngFor="let layoutNode of layout(); let i = index"
-      [class.form-flex-item]="isFlexItem()"
-      [style.flex-grow]="getFlexAttribute(layoutNode, 'flex-grow')"
-      [style.flex-shrink]="getFlexAttribute(layoutNode, 'flex-shrink')"
-      [style.flex-basis]="getFlexAttribute(layoutNode, 'flex-basis')"
-      [style.align-self]="(layoutNode?.options || {})['align-self']"
-      [style.order]="layoutNode?.options?.order"
-      [attr.fxFlex]="layoutNode?.options?.fxFlex"
-      [attr.fxFlexOrder]="layoutNode?.options?.fxFlexOrder"
-      [attr.fxFlexOffset]="layoutNode?.options?.fxFlexOffset"
-      [attr.fxFlexAlign]="layoutNode?.options?.fxFlexAlign">
-      <select-framework-widget *ngIf="showWidget(layoutNode)"
-        [dataIndex]="layoutNode?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
-        [layoutIndex]="(layoutIndex() || []).concat(i)"
-        [layoutNode]="layoutNode"></select-framework-widget>
-    <div>`, isInline: true, dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.SelectFrameworkComponent, selector: "select-framework-widget", inputs: ["layoutNode", "layoutIndex", "dataIndex"] }], changeDetection: i0.ChangeDetectionStrategy.Default }); }
+    <div cdkDropList (cdkDropListDropped)="drop($event)" 
+    [class.flex-inherit]="true"
+    >
+      <div *ngFor="let layoutNode of layout(); let i = index" 
+       cdkDrag  [cdkDragStartDelay]="{touch:1000,mouse:0}"
+        [class.form-flex-item]="isFlexItem()"
+        [style.flex-grow]="getFlexAttribute(layoutNode, 'flex-grow')"
+        [style.flex-shrink]="getFlexAttribute(layoutNode, 'flex-shrink')"
+        [style.flex-basis]="getFlexAttribute(layoutNode, 'flex-basis')"
+        [style.align-self]="(layoutNode?.options || {})['align-self']"
+        [style.order]="layoutNode?.options?.order"
+        [attr.fxFlex]="layoutNode?.options?.fxFlex"
+        [attr.fxFlexOrder]="layoutNode?.options?.fxFlexOrder"
+        [attr.fxFlexOffset]="layoutNode?.options?.fxFlexOffset"
+        [attr.fxFlexAlign]="layoutNode?.options?.fxFlexAlign"
+
+        >
+        <!-- workaround to disbale dragging of input fields -->
+        <div *ngIf="layoutNode?.dataType !='object'" cdkDragHandle>
+         <p></p>
+        </div>
+        <select-framework-widget *ngIf="showWidget(layoutNode)"
+       
+          [dataIndex]="layoutNode?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
+          [layoutIndex]="(layoutIndex() || []).concat(i)"
+          [layoutNode]="layoutNode"></select-framework-widget>
+      </div>
+    </div>`, isInline: true, styles: [".example-list{width:500px;max-width:100%;border:solid 1px #ccc;min-height:60px;display:block;background:#fff;border-radius:4px;overflow:hidden}.example-box{padding:20px 10px;border-bottom:solid 1px #ccc;color:#000000de;display:flex;flex-direction:row;align-items:center;justify-content:space-between;box-sizing:border-box;cursor:move;background:#fff;font-size:14px}.cdk-drag-preview{border:none;box-sizing:border-box;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.cdk-drag-placeholder{opacity:0}.cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}.example-box:last-child{border:none}.example-list.cdk-drop-list-dragging .example-box:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}.flex-inherit{display:inherit;flex-flow:inherit;flex-wrap:inherit;flex-direction:inherit;width:100%}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i2.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: i2.CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "component", type: i3.SelectFrameworkComponent, selector: "select-framework-widget", inputs: ["layoutNode", "layoutIndex", "dataIndex"] }], changeDetection: i0.ChangeDetectionStrategy.Default }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FlexLayoutRootComponent, decorators: [{
             type: Component,
-            args: [{
-                    // tslint:disable-next-line:component-selector
-                    selector: 'flex-layout-root-widget',
-                    template: `
-    <div *ngFor="let layoutNode of layout(); let i = index"
-      [class.form-flex-item]="isFlexItem()"
-      [style.flex-grow]="getFlexAttribute(layoutNode, 'flex-grow')"
-      [style.flex-shrink]="getFlexAttribute(layoutNode, 'flex-shrink')"
-      [style.flex-basis]="getFlexAttribute(layoutNode, 'flex-basis')"
-      [style.align-self]="(layoutNode?.options || {})['align-self']"
-      [style.order]="layoutNode?.options?.order"
-      [attr.fxFlex]="layoutNode?.options?.fxFlex"
-      [attr.fxFlexOrder]="layoutNode?.options?.fxFlexOrder"
-      [attr.fxFlexOffset]="layoutNode?.options?.fxFlexOffset"
-      [attr.fxFlexAlign]="layoutNode?.options?.fxFlexAlign">
-      <select-framework-widget *ngIf="showWidget(layoutNode)"
-        [dataIndex]="layoutNode?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
-        [layoutIndex]="(layoutIndex() || []).concat(i)"
-        [layoutNode]="layoutNode"></select-framework-widget>
-    <div>`,
-                    changeDetection: ChangeDetectionStrategy.Default,
-                }]
+            args: [{ selector: 'flex-layout-root-widget', template: `
+    <div cdkDropList (cdkDropListDropped)="drop($event)" 
+    [class.flex-inherit]="true"
+    >
+      <div *ngFor="let layoutNode of layout(); let i = index" 
+       cdkDrag  [cdkDragStartDelay]="{touch:1000,mouse:0}"
+        [class.form-flex-item]="isFlexItem()"
+        [style.flex-grow]="getFlexAttribute(layoutNode, 'flex-grow')"
+        [style.flex-shrink]="getFlexAttribute(layoutNode, 'flex-shrink')"
+        [style.flex-basis]="getFlexAttribute(layoutNode, 'flex-basis')"
+        [style.align-self]="(layoutNode?.options || {})['align-self']"
+        [style.order]="layoutNode?.options?.order"
+        [attr.fxFlex]="layoutNode?.options?.fxFlex"
+        [attr.fxFlexOrder]="layoutNode?.options?.fxFlexOrder"
+        [attr.fxFlexOffset]="layoutNode?.options?.fxFlexOffset"
+        [attr.fxFlexAlign]="layoutNode?.options?.fxFlexAlign"
+
+        >
+        <!-- workaround to disbale dragging of input fields -->
+        <div *ngIf="layoutNode?.dataType !='object'" cdkDragHandle>
+         <p></p>
+        </div>
+        <select-framework-widget *ngIf="showWidget(layoutNode)"
+       
+          [dataIndex]="layoutNode?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
+          [layoutIndex]="(layoutIndex() || []).concat(i)"
+          [layoutNode]="layoutNode"></select-framework-widget>
+      </div>
+    </div>`, changeDetection: ChangeDetectionStrategy.Default, standalone: false, styles: [".example-list{width:500px;max-width:100%;border:solid 1px #ccc;min-height:60px;display:block;background:#fff;border-radius:4px;overflow:hidden}.example-box{padding:20px 10px;border-bottom:solid 1px #ccc;color:#000000de;display:flex;flex-direction:row;align-items:center;justify-content:space-between;box-sizing:border-box;cursor:move;background:#fff;font-size:14px}.cdk-drag-preview{border:none;box-sizing:border-box;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.cdk-drag-placeholder{opacity:0}.cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}.example-box:last-child{border:none}.example-list.cdk-drop-list-dragging .example-box:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}.flex-inherit{display:inherit;flex-flow:inherit;flex-wrap:inherit;flex-direction:inherit;width:100%}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex-layout-root.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-material/src/lib/widgets/flex-layout-root.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop } from '@angular/cdk/drag-drop';\r\nimport { ChangeDetectionStrategy, Component, inject, input, OnInit } from '@angular/core';\r\nimport { JsonSchemaFormService } from '@ng-formworks/core';\r\n\r\n\r\n@Component({\r\n    // tslint:disable-next-line:component-selector\r\n    selector: 'flex-layout-root-widget',\r\n    template: `\r\n    <div cdkDropList (cdkDropListDropped)=\"drop($event)\" \r\n    [class.flex-inherit]=\"true\"\r\n    >\r\n      <div *ngFor=\"let layoutNode of layout(); let i = index\" \r\n       cdkDrag  [cdkDragStartDelay]=\"{touch:1000,mouse:0}\"\r\n        [class.form-flex-item]=\"isFlexItem()\"\r\n        [style.flex-grow]=\"getFlexAttribute(layoutNode, 'flex-grow')\"\r\n        [style.flex-shrink]=\"getFlexAttribute(layoutNode, 'flex-shrink')\"\r\n        [style.flex-basis]=\"getFlexAttribute(layoutNode, 'flex-basis')\"\r\n        [style.align-self]=\"(layoutNode?.options || {})['align-self']\"\r\n        [style.order]=\"layoutNode?.options?.order\"\r\n        [attr.fxFlex]=\"layoutNode?.options?.fxFlex\"\r\n        [attr.fxFlexOrder]=\"layoutNode?.options?.fxFlexOrder\"\r\n        [attr.fxFlexOffset]=\"layoutNode?.options?.fxFlexOffset\"\r\n        [attr.fxFlexAlign]=\"layoutNode?.options?.fxFlexAlign\"\r\n\r\n        >\r\n        <!-- workaround to disbale dragging of input fields -->\r\n        <div *ngIf=\"layoutNode?.dataType !='object'\" cdkDragHandle>\r\n         <p></p>\r\n        </div>\r\n        <select-framework-widget *ngIf=\"showWidget(layoutNode)\"\r\n       \r\n          [dataIndex]=\"layoutNode?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])\"\r\n          [layoutIndex]=\"(layoutIndex() || []).concat(i)\"\r\n          [layoutNode]=\"layoutNode\"></select-framework-widget>\r\n      </div>\r\n    </div>`,\r\n    styles:`\r\n    .example-list {\r\n  width: 500px;\r\n  max-width: 100%;\r\n  border: solid 1px #ccc;\r\n  min-height: 60px;\r\n  display: block;\r\n  background: white;\r\n  border-radius: 4px;\r\n  overflow: hidden;\r\n}\r\n\r\n.example-box {\r\n  padding: 20px 10px;\r\n  border-bottom: solid 1px #ccc;\r\n  color: rgba(0, 0, 0, 0.87);\r\n  display: flex;\r\n  flex-direction: row;\r\n  align-items: center;\r\n  justify-content: space-between;\r\n  box-sizing: border-box;\r\n  cursor: move;\r\n  background: white;\r\n  font-size: 14px;\r\n}\r\n\r\n.cdk-drag-preview {\r\n  border: none;\r\n  box-sizing: border-box;\r\n  border-radius: 4px;\r\n  box-shadow: 0 5px 5px -3px rgba(0, 0, 0, 0.2),\r\n              0 8px 10px 1px rgba(0, 0, 0, 0.14),\r\n              0 3px 14px 2px rgba(0, 0, 0, 0.12);\r\n}\r\n\r\n.cdk-drag-placeholder {\r\n  opacity: 0;\r\n}\r\n\r\n.cdk-drag-animating {\r\n  transition: transform 250ms cubic-bezier(0, 0, 0.2, 1);\r\n}\r\n\r\n.example-box:last-child {\r\n  border: none;\r\n}\r\n\r\n.example-list.cdk-drop-list-dragging .example-box:not(.cdk-drag-placeholder) {\r\n  transition: transform 250ms cubic-bezier(0, 0, 0.2, 1);\r\n}\r\n.flex-inherit{\r\n    display:inherit;\r\n    flex-flow:inherit;\r\n    flex-wrap:inherit;\r\n    flex-direction:inherit;\r\n    width:100%\r\n}\r\n    \r\n`,\r\n    changeDetection: ChangeDetectionStrategy.Default,\r\n    standalone: false\r\n})\r\nexport class FlexLayoutRootComponent implements OnInit {\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  readonly dataIndex = input<number[]>(undefined);\r\n  readonly layoutIndex = input<number[]>(undefined);\r\n  readonly layout = input<any[]>(undefined);\r\n  readonly isFlexItem = input(false);\r\n  ngOnInit() {\r\n    console.log(\"debug FlexLayoutRootComponent:\"+this);\r\n  }\r\n  removeItem(item) {\r\n    this.jsf.removeItem(item);\r\n  }\r\n  sortableObj: any;\r\n  sortableConfig:any={\r\n    filter:\".sortable-filter\",//needed to disable dragging on input range elements, class needs to be added to the element or its parent\r\n    preventOnFilter: false,//needed for input range elements slider do still work\r\n    onEnd: (/**Event*/evt)=> {\r\n\r\n      \r\n    }\r\n  }\r\n  sortableInit(sortable) {\r\n    this.sortableObj = sortable;\r\n  }\r\n\r\n  drop(event: CdkDragDrop<string[]>) {\r\n    // most likely why this event is used is to get the dragging element's current index\r\n    // same properties as onEnd\r\n    //console.log(`sortablejs event:${evt}`);\r\n    let srcInd=event.previousIndex;\r\n    let trgInd=event.currentIndex;\r\n    let layoutItem=this.layout()[trgInd];\r\n    let dataInd=layoutItem?.arrayItem ? (this.dataIndex() || []).concat(trgInd) : (this.dataIndex() || []);\r\n    let layoutInd=(this.layoutIndex() || []).concat(trgInd)\r\n    let itemCtx:any={\r\n      dataIndex:()=>{return dataInd},\r\n      layoutIndex:()=>{return layoutInd},\r\n      layoutNode:()=>{return layoutItem},\r\n    }\r\n    //must set moveLayout to false as nxtSortable already moves it\r\n    this.jsf.moveArrayItem(itemCtx, srcInd, trgInd,true);\r\n  }\r\n\r\n  // Set attributes for flexbox child\r\n  // (container attributes are set in flex-layout-section.component)\r\n  getFlexAttribute(node: any, attribute: string) {\r\n    const index = ['flex-grow', 'flex-shrink', 'flex-basis'].indexOf(attribute);\r\n    return ((node.options || {}).flex || '').split(/\\s+/)[index] ||\r\n      (node.options || {})[attribute] || ['1', '1', 'auto'][index];\r\n  }\r\n\r\n  showWidget(layoutNode: any): boolean {\r\n    return this.jsf.evaluateCondition(layoutNode, this.dataIndex());\r\n  }\r\n}\r\n"]}

package/esm2022/lib/widgets/flex-layout-section.component.mjs

@@ -78,6 +78,7 @@ export class FlexLayoutSectionComponent {
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FlexLayoutSectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: FlexLayoutSectionComponent, selector: "flex-layout-section-widget", inputs: { layoutNode: { classPropertyName: "layoutNode", publicName: "layoutNode", isSignal: true, isRequired: false, transformFunction: null }, layoutIndex: { classPropertyName: "layoutIndex", publicName: "layoutIndex", isSignal: true, isRequired: false, transformFunction: null }, dataIndex: { classPropertyName: "dataIndex", publicName: "dataIndex", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+
     <div *ngIf="containerType === 'div'"
       [class]="options?.htmlClass || ''"
       [class.expandable]="options?.expandable && !expanded"
@@ -86,14 +87,14 @@ export class FlexLayoutSectionComponent {
         [class]="'legend ' + (options?.labelHtmlClass || '')"
         [innerHTML]="sectionTitle"
         (click)="toggleExpanded()"></label>
-      <flex-layout-root-widget *ngIf="expanded"
+      <flex-layout-root-widget 
         [layout]="layoutNode().items"
         [dataIndex]="dataIndex()"
         [layoutIndex]="layoutIndex()"
         [isFlexItem]="getFlexAttribute('is-flex')"
         [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
         [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-        [style.display]="getFlexAttribute('display')"
+        [style.display]="!expanded?'none':getFlexAttribute('display')"
         [style.flex-direction]="getFlexAttribute('flex-direction')"
         [style.flex-wrap]="getFlexAttribute('flex-wrap')"
         [style.justify-content]="getFlexAttribute('justify-content')"
@@ -116,14 +117,14 @@ export class FlexLayoutSectionComponent {
         [class]="'legend ' + (options?.labelHtmlClass || '')"
         [innerHTML]="sectionTitle"
         (click)="toggleExpanded()"></legend>
-      <flex-layout-root-widget *ngIf="expanded"
+      <flex-layout-root-widget 
         [layout]="layoutNode().items"
         [dataIndex]="dataIndex()"
         [layoutIndex]="layoutIndex()"
         [isFlexItem]="getFlexAttribute('is-flex')"
         [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
         [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-        [style.display]="getFlexAttribute('display')"
+        [style.display]="!expanded?'none':getFlexAttribute('display')"
         [style.flex-direction]="getFlexAttribute('flex-direction')"
         [style.flex-wrap]="getFlexAttribute('flex-wrap')"
         [style.justify-content]="getFlexAttribute('justify-content')"
@@ -147,16 +148,16 @@ export class FlexLayoutSectionComponent {
           [innerHTML]="sectionTitle"
           (click)="toggleExpanded()"></legend>
       </mat-card-header>
-      <mat-card-content *ngIf="expanded">
+      <mat-card-content >
         <fieldset [disabled]="options?.readonly">
-          <flex-layout-root-widget *ngIf="expanded"
+          <flex-layout-root-widget 
             [layout]="layoutNode().items"
             [dataIndex]="dataIndex()"
             [layoutIndex]="layoutIndex()"
             [isFlexItem]="getFlexAttribute('is-flex')"
             [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
             [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-            [style.display]="getFlexAttribute('display')"
+            [style.display]="!expanded?'none':getFlexAttribute('display')"
             [style.flex-direction]="getFlexAttribute('flex-direction')"
             [style.flex-wrap]="getFlexAttribute('flex-wrap')"
             [style.justify-content]="getFlexAttribute('justify-content')"
@@ -186,14 +187,14 @@ export class FlexLayoutSectionComponent {
         </mat-panel-title>
       </mat-expansion-panel-header>
       <fieldset [disabled]="options?.readonly">
-        <flex-layout-root-widget *ngIf="expanded"
+        <flex-layout-root-widget 
           [layout]="layoutNode().items"
           [dataIndex]="dataIndex()"
           [layoutIndex]="layoutIndex()"
           [isFlexItem]="getFlexAttribute('is-flex')"
           [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
           [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-          [style.display]="getFlexAttribute('display')"
+          [style.display]="!expanded?'none':getFlexAttribute('display')"
           [style.flex-direction]="getFlexAttribute('flex-direction')"
           [style.flex-wrap]="getFlexAttribute('flex-wrap')"
           [style.justify-content]="getFlexAttribute('justify-content')"
@@ -211,6 +212,7 @@ export class FlexLayoutSectionComponent {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FlexLayoutSectionComponent, decorators: [{
             type: Component,
             args: [{ selector: 'flex-layout-section-widget', template: `
+
     <div *ngIf="containerType === 'div'"
       [class]="options?.htmlClass || ''"
       [class.expandable]="options?.expandable && !expanded"
@@ -219,14 +221,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         [class]="'legend ' + (options?.labelHtmlClass || '')"
         [innerHTML]="sectionTitle"
         (click)="toggleExpanded()"></label>
-      <flex-layout-root-widget *ngIf="expanded"
+      <flex-layout-root-widget 
         [layout]="layoutNode().items"
         [dataIndex]="dataIndex()"
         [layoutIndex]="layoutIndex()"
         [isFlexItem]="getFlexAttribute('is-flex')"
         [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
         [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-        [style.display]="getFlexAttribute('display')"
+        [style.display]="!expanded?'none':getFlexAttribute('display')"
         [style.flex-direction]="getFlexAttribute('flex-direction')"
         [style.flex-wrap]="getFlexAttribute('flex-wrap')"
         [style.justify-content]="getFlexAttribute('justify-content')"
@@ -249,14 +251,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         [class]="'legend ' + (options?.labelHtmlClass || '')"
         [innerHTML]="sectionTitle"
         (click)="toggleExpanded()"></legend>
-      <flex-layout-root-widget *ngIf="expanded"
+      <flex-layout-root-widget 
         [layout]="layoutNode().items"
         [dataIndex]="dataIndex()"
         [layoutIndex]="layoutIndex()"
         [isFlexItem]="getFlexAttribute('is-flex')"
         [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
         [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-        [style.display]="getFlexAttribute('display')"
+        [style.display]="!expanded?'none':getFlexAttribute('display')"
         [style.flex-direction]="getFlexAttribute('flex-direction')"
         [style.flex-wrap]="getFlexAttribute('flex-wrap')"
         [style.justify-content]="getFlexAttribute('justify-content')"
@@ -280,16 +282,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
           [innerHTML]="sectionTitle"
           (click)="toggleExpanded()"></legend>
       </mat-card-header>
-      <mat-card-content *ngIf="expanded">
+      <mat-card-content >
         <fieldset [disabled]="options?.readonly">
-          <flex-layout-root-widget *ngIf="expanded"
+          <flex-layout-root-widget 
             [layout]="layoutNode().items"
             [dataIndex]="dataIndex()"
             [layoutIndex]="layoutIndex()"
             [isFlexItem]="getFlexAttribute('is-flex')"
             [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
             [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-            [style.display]="getFlexAttribute('display')"
+            [style.display]="!expanded?'none':getFlexAttribute('display')"
             [style.flex-direction]="getFlexAttribute('flex-direction')"
             [style.flex-wrap]="getFlexAttribute('flex-wrap')"
             [style.justify-content]="getFlexAttribute('justify-content')"
@@ -319,14 +321,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         </mat-panel-title>
       </mat-expansion-panel-header>
       <fieldset [disabled]="options?.readonly">
-        <flex-layout-root-widget *ngIf="expanded"
+        <flex-layout-root-widget 
           [layout]="layoutNode().items"
           [dataIndex]="dataIndex()"
           [layoutIndex]="layoutIndex()"
           [isFlexItem]="getFlexAttribute('is-flex')"
           [class.form-flex-column]="getFlexAttribute('flex-direction') === 'column'"
           [class.form-flex-row]="getFlexAttribute('flex-direction') === 'row'"
-          [style.display]="getFlexAttribute('display')"
+          [style.display]="!expanded?'none':getFlexAttribute('display')"
           [style.flex-direction]="getFlexAttribute('flex-direction')"
           [style.flex-wrap]="getFlexAttribute('flex-wrap')"
           [style.justify-content]="getFlexAttribute('justify-content')"
@@ -341,4 +343,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         [innerHTML]="options?.errorMessage"></mat-error>
     </mat-expansion-panel>`, styles: ["fieldset{border:0;margin:0;padding:0}.legend{font-weight:700}.expandable>.legend:before{content:\"\\25b6\";padding-right:.3em;font-family:auto}.expanded>.legend:before{content:\"\\25bc\";padding-right:.2em}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex-layout-section.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-material/src/lib/widgets/flex-layout-section.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, inject, input } from '@angular/core';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { JsonSchemaFormService } from '@ng-formworks/core';\r\n\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: 'flex-layout-section-widget',\r\n  template: `\r\n    <div *ngIf=\"containerType === 'div'\"\r\n      [class]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\">\r\n      <label *ngIf=\"sectionTitle\"\r\n        [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></label>\r\n      <flex-layout-root-widget *ngIf=\"expanded\"\r\n        [layout]=\"layoutNode().items\"\r\n        [dataIndex]=\"dataIndex()\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.display]=\"getFlexAttribute('display')\"\r\n        [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n        [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n        [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n        [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n        [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n        [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </div>\r\n\r\n    <fieldset *ngIf=\"containerType === 'fieldset'\"\r\n      [class]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\"\r\n      [disabled]=\"options?.readonly\">\r\n      <legend *ngIf=\"sectionTitle\"\r\n        [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></legend>\r\n      <flex-layout-root-widget *ngIf=\"expanded\"\r\n        [layout]=\"layoutNode().items\"\r\n        [dataIndex]=\"dataIndex()\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.display]=\"getFlexAttribute('display')\"\r\n        [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n        [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n        [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n        [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n        [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n        [attr.attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </fieldset>\r\n\r\n    <mat-card appearance=\"outlined\" *ngIf=\"containerType === 'card'\"\r\n      [ngClass]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\">\r\n      <mat-card-header *ngIf=\"sectionTitle\">\r\n        <legend\r\n          [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n          [innerHTML]=\"sectionTitle\"\r\n          (click)=\"toggleExpanded()\"></legend>\r\n      </mat-card-header>\r\n      <mat-card-content *ngIf=\"expanded\">\r\n        <fieldset [disabled]=\"options?.readonly\">\r\n          <flex-layout-root-widget *ngIf=\"expanded\"\r\n            [layout]=\"layoutNode().items\"\r\n            [dataIndex]=\"dataIndex()\"\r\n            [layoutIndex]=\"layoutIndex()\"\r\n            [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n            [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n            [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n            [style.display]=\"getFlexAttribute('display')\"\r\n            [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n            [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n            [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n            [style.align-items]=\"getFlexAttribute('align-items')\"\r\n            [style.align-content]=\"getFlexAttribute('align-content')\"\r\n            [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n            [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n            [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n            [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n          </fieldset>\r\n      </mat-card-content>\r\n      <mat-card-footer>\r\n        <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n          [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n      </mat-card-footer>\r\n    </mat-card>\r\n\r\n    <mat-expansion-panel *ngIf=\"containerType === 'expansion-panel'\"\r\n      [expanded]=\"expanded\"\r\n      [hideToggle]=\"!options?.expandable\">\r\n      <mat-expansion-panel-header>\r\n        <mat-panel-title>\r\n          <legend *ngIf=\"sectionTitle\"\r\n            [class]=\"options?.labelHtmlClass\"\r\n            [innerHTML]=\"sectionTitle\"\r\n            (click)=\"toggleExpanded()\"></legend>\r\n        </mat-panel-title>\r\n      </mat-expansion-panel-header>\r\n      <fieldset [disabled]=\"options?.readonly\">\r\n        <flex-layout-root-widget *ngIf=\"expanded\"\r\n          [layout]=\"layoutNode().items\"\r\n          [dataIndex]=\"dataIndex()\"\r\n          [layoutIndex]=\"layoutIndex()\"\r\n          [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n          [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n          [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n          [style.display]=\"getFlexAttribute('display')\"\r\n          [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n          [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n          [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n          [style.align-items]=\"getFlexAttribute('align-items')\"\r\n          [style.align-content]=\"getFlexAttribute('align-content')\"\r\n          [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n          [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n          [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n          [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      </fieldset>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </mat-expansion-panel>`,\r\n  styles: [`\r\n    fieldset { border: 0; margin: 0; padding: 0; }\r\n    .legend { font-weight: bold; }\r\n    .expandable > .legend:before { content: '▶'; padding-right: .3em; font-family:auto }\r\n    .expanded > .legend:before { content: '▼'; padding-right: .2em; }\r\n  `],\r\n})\r\nexport class FlexLayoutSectionComponent implements OnInit {\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  formControl: AbstractControl;\r\n  controlName: string;\r\n  controlValue: any;\r\n  controlDisabled = false;\r\n  boundControl = false;\r\n  options: any;\r\n  expanded = true;\r\n  containerType = 'div';\r\n  readonly layoutNode = input<any>(undefined);\r\n  readonly layoutIndex = input<number[]>(undefined);\r\n  readonly dataIndex = input<number[]>(undefined);\r\n\r\n  get sectionTitle() {\r\n    return this.options.notitle ? null : this.jsf.setItemTitle(this);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.jsf.initializeControl(this);\r\n    this.options = this.layoutNode().options || {};\r\n    this.expanded = typeof this.options.expanded === 'boolean' ?\r\n      this.options.expanded : !this.options.expandable;\r\n    switch (this.layoutNode().type) {\r\n      case 'section': case 'array': case 'fieldset': case 'advancedfieldset':\r\n      case 'authfieldset': case 'optionfieldset': case 'selectfieldset':\r\n        this.containerType = 'fieldset';\r\n        break;\r\n      case 'card':\r\n        this.containerType = 'card';\r\n        break;\r\n      case 'expansion-panel':\r\n        this.containerType = 'expansion-panel';\r\n        break;\r\n      default: // 'div', 'flex', 'tab', 'conditional', 'actions'\r\n        this.containerType = 'div';\r\n    }\r\n  }\r\n\r\n  toggleExpanded() {\r\n    if (this.options.expandable) { this.expanded = !this.expanded; }\r\n  }\r\n\r\n  // Set attributes for flexbox container\r\n  // (child attributes are set in flex-layout-root.component)\r\n  getFlexAttribute(attribute: string) {\r\n    const flexActive: boolean =\r\n      this.layoutNode().type === 'flex' ||\r\n      !!this.options.displayFlex ||\r\n      this.options.display === 'flex';\r\n    // if (attribute !== 'flex' && !flexActive) { return null; }\r\n    switch (attribute) {\r\n      case 'is-flex':\r\n        return flexActive;\r\n      case 'display':\r\n        return flexActive ? 'flex' : 'initial';\r\n      case 'flex-direction': case 'flex-wrap':\r\n        const index = ['flex-direction', 'flex-wrap'].indexOf(attribute);\r\n        return (this.options['flex-flow'] || '').split(/\\s+/)[index] ||\r\n          this.options[attribute] || ['column', 'nowrap'][index];\r\n      case 'justify-content': case 'align-items': case 'align-content':\r\n        return this.options[attribute];\r\n      case 'layout':\r\n        return (this.options.fxLayout || 'row') +\r\n          this.options.fxLayoutWrap ? ' ' + this.options.fxLayoutWrap : '';\r\n\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex-layout-section.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-material/src/lib/widgets/flex-layout-section.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, inject, input } from '@angular/core';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { JsonSchemaFormService } from '@ng-formworks/core';\r\n\r\n@Component({\r\n    // tslint:disable-next-line:component-selector\r\n    selector: 'flex-layout-section-widget',\r\n    template: `\r\n\r\n    <div *ngIf=\"containerType === 'div'\"\r\n      [class]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\">\r\n      <label *ngIf=\"sectionTitle\"\r\n        [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></label>\r\n      <flex-layout-root-widget \r\n        [layout]=\"layoutNode().items\"\r\n        [dataIndex]=\"dataIndex()\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.display]=\"!expanded?'none':getFlexAttribute('display')\"\r\n        [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n        [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n        [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n        [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n        [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n        [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </div>\r\n\r\n    <fieldset *ngIf=\"containerType === 'fieldset'\"\r\n      [class]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\"\r\n      [disabled]=\"options?.readonly\">\r\n      <legend *ngIf=\"sectionTitle\"\r\n        [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></legend>\r\n      <flex-layout-root-widget \r\n        [layout]=\"layoutNode().items\"\r\n        [dataIndex]=\"dataIndex()\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.display]=\"!expanded?'none':getFlexAttribute('display')\"\r\n        [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n        [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n        [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n        [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n        [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n        [attr.attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </fieldset>\r\n\r\n    <mat-card appearance=\"outlined\" *ngIf=\"containerType === 'card'\"\r\n      [ngClass]=\"options?.htmlClass || ''\"\r\n      [class.expandable]=\"options?.expandable && !expanded\"\r\n      [class.expanded]=\"options?.expandable && expanded\">\r\n      <mat-card-header *ngIf=\"sectionTitle\">\r\n        <legend\r\n          [class]=\"'legend ' + (options?.labelHtmlClass || '')\"\r\n          [innerHTML]=\"sectionTitle\"\r\n          (click)=\"toggleExpanded()\"></legend>\r\n      </mat-card-header>\r\n      <mat-card-content >\r\n        <fieldset [disabled]=\"options?.readonly\">\r\n          <flex-layout-root-widget \r\n            [layout]=\"layoutNode().items\"\r\n            [dataIndex]=\"dataIndex()\"\r\n            [layoutIndex]=\"layoutIndex()\"\r\n            [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n            [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n            [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n            [style.display]=\"!expanded?'none':getFlexAttribute('display')\"\r\n            [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n            [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n            [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n            [style.align-items]=\"getFlexAttribute('align-items')\"\r\n            [style.align-content]=\"getFlexAttribute('align-content')\"\r\n            [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n            [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n            [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n            [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n          </fieldset>\r\n      </mat-card-content>\r\n      <mat-card-footer>\r\n        <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n          [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n      </mat-card-footer>\r\n    </mat-card>\r\n\r\n    <mat-expansion-panel *ngIf=\"containerType === 'expansion-panel'\"\r\n      [expanded]=\"expanded\"\r\n      [hideToggle]=\"!options?.expandable\">\r\n      <mat-expansion-panel-header>\r\n        <mat-panel-title>\r\n          <legend *ngIf=\"sectionTitle\"\r\n            [class]=\"options?.labelHtmlClass\"\r\n            [innerHTML]=\"sectionTitle\"\r\n            (click)=\"toggleExpanded()\"></legend>\r\n        </mat-panel-title>\r\n      </mat-expansion-panel-header>\r\n      <fieldset [disabled]=\"options?.readonly\">\r\n        <flex-layout-root-widget \r\n          [layout]=\"layoutNode().items\"\r\n          [dataIndex]=\"dataIndex()\"\r\n          [layoutIndex]=\"layoutIndex()\"\r\n          [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n          [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n          [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n          [style.display]=\"!expanded?'none':getFlexAttribute('display')\"\r\n          [style.flex-direction]=\"getFlexAttribute('flex-direction')\"\r\n          [style.flex-wrap]=\"getFlexAttribute('flex-wrap')\"\r\n          [style.justify-content]=\"getFlexAttribute('justify-content')\"\r\n          [style.align-items]=\"getFlexAttribute('align-items')\"\r\n          [style.align-content]=\"getFlexAttribute('align-content')\"\r\n          [attr.fxLayout]=\"getFlexAttribute('layout')\"\r\n          [attr.fxLayoutGap]=\"options?.fxLayoutGap\"\r\n          [attr.fxLayoutAlign]=\"options?.fxLayoutAlign\"\r\n          [attr.fxFlexFill]=\"options?.fxLayoutAlign\"></flex-layout-root-widget>\r\n      </fieldset>\r\n      <mat-error *ngIf=\"options?.showErrors && options?.errorMessage\"\r\n        [innerHTML]=\"options?.errorMessage\"></mat-error>\r\n    </mat-expansion-panel>`,\r\n  styles: [`\r\n    fieldset { border: 0; margin: 0; padding: 0; }\r\n    .legend { font-weight: bold; }\r\n    .expandable > .legend:before { content: '▶'; padding-right: .3em; font-family:auto }\r\n    .expanded > .legend:before { content: '▼'; padding-right: .2em; }\r\n  `],\r\n})\r\nexport class FlexLayoutSectionComponent implements OnInit {\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  formControl: AbstractControl;\r\n  controlName: string;\r\n  controlValue: any;\r\n  controlDisabled = false;\r\n  boundControl = false;\r\n  options: any;\r\n  expanded = true;\r\n  containerType = 'div';\r\n  readonly layoutNode = input<any>(undefined);\r\n  readonly layoutIndex = input<number[]>(undefined);\r\n  readonly dataIndex = input<number[]>(undefined);\r\n\r\n  get sectionTitle() {\r\n    return this.options.notitle ? null : this.jsf.setItemTitle(this);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.jsf.initializeControl(this);\r\n    this.options = this.layoutNode().options || {};\r\n    this.expanded = typeof this.options.expanded === 'boolean' ?\r\n      this.options.expanded : !this.options.expandable;\r\n    switch (this.layoutNode().type) {\r\n      case 'section': case 'array': case 'fieldset': case 'advancedfieldset':\r\n      case 'authfieldset': case 'optionfieldset': case 'selectfieldset':\r\n        this.containerType = 'fieldset';\r\n        break;\r\n      case 'card':\r\n        this.containerType = 'card';\r\n        break;\r\n      case 'expansion-panel':\r\n        this.containerType = 'expansion-panel';\r\n        break;\r\n      default: // 'div', 'flex', 'tab', 'conditional', 'actions'\r\n        this.containerType = 'div';\r\n    }\r\n  }\r\n\r\n  toggleExpanded() {\r\n    if (this.options.expandable) { this.expanded = !this.expanded; }\r\n  }\r\n\r\n  // Set attributes for flexbox container\r\n  // (child attributes are set in flex-layout-root.component)\r\n  getFlexAttribute(attribute: string) {\r\n    const flexActive: boolean =\r\n      this.layoutNode().type === 'flex' ||\r\n      !!this.options.displayFlex ||\r\n      this.options.display === 'flex';\r\n    // if (attribute !== 'flex' && !flexActive) { return null; }\r\n    switch (attribute) {\r\n      case 'is-flex':\r\n        return flexActive;\r\n      case 'display':\r\n        return flexActive ? 'flex' : 'initial';\r\n      case 'flex-direction': case 'flex-wrap':\r\n        const index = ['flex-direction', 'flex-wrap'].indexOf(attribute);\r\n        return (this.options['flex-flow'] || '').split(/\\s+/)[index] ||\r\n          this.options[attribute] || ['column', 'nowrap'][index];\r\n      case 'justify-content': case 'align-items': case 'align-content':\r\n        return this.options[attribute];\r\n      case 'layout':\r\n        return (this.options.fxLayout || 'row') +\r\n          this.options.fxLayoutWrap ? ' ' + this.options.fxLayoutWrap : '';\r\n\r\n    }\r\n  }\r\n}\r\n"]}