@ng-formworks/core 17.6.5 → 17.6.7

package/esm2022/lib/widget-library/root.component.mjs

@@ -1,10 +1,10 @@
-import { Component, inject, input } from '@angular/core';
+import { ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { memoize } from 'lodash';
 import { JsonSchemaFormService } from '../json-schema-form.service';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
-import * as i2 from "nxt-sortablejs";
+import * as i2 from "@angular/cdk/drag-drop";
 import * as i3 from "./select-framework.component";
-import * as i4 from "./orderable.directive";
 export class RootComponent {
     constructor() {
         this.jsf = inject(JsonSchemaFormService);
@@ -13,105 +13,84 @@ export class RootComponent {
         this.layout = input(undefined);
         this.isOrderable = input(undefined);
         this.isFlexItem = input(false);
-        this.sortableConfig = {
-            filter: ".sortable-filter",
-            preventOnFilter: false,
-            delay: 1000,
-            delayOnTouchOnly: true,
-            onEnd: (/**Event*/ evt) => {
-                evt.newIndex; // 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 = evt.oldIndex;
-                let trgInd = evt.newIndex;
-                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, evt.oldIndex, evt.newIndex, false);
-            },
-            onMove: function (/**Event*/ evt, /**Event*/ originalEvent) {
-                if (evt.related.classList.contains("sortable-fixed")) {
-                    //console.log(evt.related);
-                    return false;
-                }
-            }
+        this.memoizationEnabled = input(true);
+        /**
+         * Predicate function that disallows '$ref' item sorts
+         * NB declared as a var instead of a function
+         * like sortPredicate(index: number, item: CdkDrag<number>){..}
+         * since 'this' is bound to the draglist and doesn't reference the
+         * FlexLayoutRootComponent instance
+         */
+        //TODO also need to think of other types such as button which can be
+        //created by an arbitrary layout
+        //might not be needed added condition to [cdkDragDisabled]
+        this.sortPredicate = (index, item) => {
+            let layoutItem = this.layout()[index];
+            let result = this.isDraggable(layoutItem);
+            //layoutItem.type != '$ref';
+            return result;
         };
-    }
-    sortableInit(sortable) {
-        this.sortableObj = sortable;
-        //Sortable.utils.on(this.sortableObj.el,"nulling",(s)=>{console.log("event nulling sortablejs")})
-        ///NB issue caused by sortablejs when it its destroyed
-        //this mainly affects checkboxes coupled with conditions
-        //-the value is rechecked
-        //-see https://github.com/SortableJS/Sortable/issues/1052#issuecomment-369613072
-        /* attempt to monkey patch sortable js
-        const originalMethod = sortable._nulling;
-        let zone=this.zone;
-        sortable._nulling=function() {
-          console.log(`pluginEvent 2 ${pluginEvent}`)
-                zone.runOutsideAngular(() => {
-                  console.log(`pluginEvent3 ${pluginEvent}`)
-          pluginEvent('nulling', this);
-      
-          rootEl =
-          dragEl =
-          parentEl =
-          ghostEl =
-          nextEl =
-          cloneEl =
-          lastDownEl =
-          cloneHidden =
-      
-          tapEvt =
-          touchEvt =
+        //private selectframeworkInputCache = new Map<string, { dataIndex: any[], layoutIndex: any[], layoutNode: any }>();
+        //TODO review caching-if form field values change, the changes are not propagated
+        /*
+        getSelectFrameworkInputs(layoutItem: any, i: number) {
+          // Create a unique key based on the layoutItem and index
+          const cacheKey = `${layoutItem._id}-${i}`;
+        
+          // If the result is already in the cache, return it
+          if(this.enableCaching){
+            if (this.selectframeworkInputCache.has(cacheKey)) {
+              return this.selectframeworkInputCache.get(cacheKey);
+            }
+          }
       
-          moved =
-          newIndex =
-          newDraggableIndex =
-          oldIndex =
-          oldDraggableIndex =
       
-          lastTarget =
-          lastDirection =
+          // If not cached, calculate the values (assuming dataIndex() and layoutIndex() are functions)
+          const dataIndex = layoutItem?.arrayItem ? (this.dataIndex() || []).concat(i) : (this.dataIndex() || []);
+          const layoutIndex = (this.layoutIndex() || []).concat(i);
       
-          putSortable =
-          activeGroup =
-          Sortable.dragged =
-          Sortable.ghost =
-          Sortable.clone =
-          Sortable.active = null;
+          // Save the result in the cache
+          const result = { dataIndex, layoutIndex, layoutNode: layoutItem };
+          if(this.enableCaching){
+            this.selectframeworkInputCache.set(cacheKey, result);
+          }
       
-        
-            let el = this.el;
-            savedInputChecked.forEach(function (checkEl) {
-              if (el.contains(checkEl)) {
-                checkEl.checked = true;
-              }
-            });
-        
-            savedInputChecked.length =
-            lastDx =
-            lastDy = 0;
-    
-          })
-    
-        }.bind(sortable)
-        */
+          return result;
+        }
+          */
+        this._getSelectFrameworkInputsRaw = (layoutItem, i) => {
+            const dataIndexValue = this.dataIndex() || [];
+            const layoutIndexValue = this.layoutIndex() || [];
+            return {
+                layoutNode: layoutItem,
+                layoutIndex: [...layoutIndexValue, i],
+                dataIndex: layoutItem?.arrayItem ? [...dataIndexValue, i] : dataIndexValue,
+            };
+        };
+        // Define a separate function to hold the memoized version
+        this._getSelectFrameworkInputsMemoized = memoize(this._getSelectFrameworkInputsRaw, (layoutItem, i) => {
+            const layoutItemKey = layoutItem?.id ?? JSON.stringify(layoutItem);
+            return `${layoutItemKey}-${i}`;
+        });
+    }
+    drop(event) {
+        // most likely why this event is used is to get the dragging element's current index
+        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; },
+        };
+        this.jsf.moveArrayItem(itemCtx, srcInd, trgInd, true);
     }
     isDraggable(node) {
         let result = node.arrayItem && node.type !== '$ref' &&
-            node.arrayItemType === 'list' && this.isOrderable() !== false;
-        if (this.sortableObj) {
-            //this.sortableObj.option("disabled",true);
-            //this.sortableObj.option("sort",false);
-            //this.sortableObj.option("disabled",!result);
-        }
+            node.arrayItemType === 'list' && this.isOrderable() !== false
+            && node.type !== 'submit';
         return result;
     }
     //TODO also need to think of other types such as button which can be
@@ -127,92 +106,156 @@ export class RootComponent {
         return ((node.options || {}).flex || '').split(/\s+/)[index] ||
             (node.options || {})[attribute] || ['1', '1', 'auto'][index];
     }
+    // This is the public function that the template calls
+    getSelectFrameworkInputs(layoutItem, i) {
+        if (this.memoizationEnabled) {
+            return this._getSelectFrameworkInputsMemoized(layoutItem, i);
+        }
+        else {
+            return this._getSelectFrameworkInputsRaw(layoutItem, i);
+        }
+    }
+    trackByFn(index, item) {
+        return item._id ?? index;
+    }
+    /*
+    ngOnChanges(changes: SimpleChanges): void {
+      // If any of the input properties change, clear the cache
+      if (changes.dataIndex || changes.layoutIndex || changes.layout) {
+        this.selectframeworkInputCache?.clear(); // Clear the entire cache
+      }
+    }
+    */
+    ngOnChanges(changes) {
+        if (changes['layout'] || changes['dataIndex'] || changes['layoutIndex']) {
+            // Clear the entire cache of the memoized function
+            this._getSelectFrameworkInputsMemoized.cache.clear();
+        }
+    }
     showWidget(layoutNode) {
         return this.jsf.evaluateCondition(layoutNode, this.dataIndex());
     }
     ngOnInit() {
-        // Subscribe to the draggable state
-        this.sortableOptionsSubscription = this.jsf.sortableOptions$.subscribe((optsValue) => {
-            if (this.sortableObj) {
-                Object.keys(optsValue).forEach(opt => {
-                    let optVal = optsValue[opt];
-                    this.sortableObj.option(opt, optVal);
-                });
-                //this.sortableObj.option("disabled",true);
-                //this.sortableObj.option("sort",false);
-            }
-        });
+        if (this.memoizationEnabled) {
+            this.jsf.dataChanges.subscribe((val) => {
+                //this.selectframeworkInputCache?.clear();
+                this._getSelectFrameworkInputsMemoized.cache.clear();
+            });
+        }
     }
     ngOnDestroy() {
-        if (this.sortableOptionsSubscription) {
-            this.sortableOptionsSubscription.unsubscribe();
-        }
+        //this.selectframeworkInputCache?.clear()
+        //this.selectframeworkInputCache=null;
+        this._getSelectFrameworkInputsMemoized.cache.clear();
+        this.dataChangesSubs?.unsubscribe();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: RootComponent, selector: "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 }, isOrderable: { classPropertyName: "isOrderable", publicName: "isOrderable", isSignal: true, isRequired: false, transformFunction: null }, isFlexItem: { classPropertyName: "isFlexItem", publicName: "isFlexItem", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
-    <div [class.flex-inherit]="true" #sortableContainter [nxtSortablejs]="layout()" [config]="sortableConfig" (init)="sortableInit($event)">
-      <div *ngFor="let layoutItem of layout(); let i = index"
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: RootComponent, selector: "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 }, isOrderable: { classPropertyName: "isOrderable", publicName: "isOrderable", isSignal: true, isRequired: false, transformFunction: null }, isFlexItem: { classPropertyName: "isFlexItem", publicName: "isFlexItem", isSignal: true, isRequired: false, transformFunction: null }, memoizationEnabled: { classPropertyName: "memoizationEnabled", publicName: "memoizationEnabled", isSignal: true, isRequired: false, transformFunction: null } }, usesOnChanges: true, ngImport: i0, template: `
+    <div cdkDropList (cdkDropListDropped)="drop($event)" 
+      [class.flex-inherit]="true"
+      [cdkDropListSortPredicate]="sortPredicate"
+    >
+      <!-- -for now left out
+      cdkDragHandle directive, by itself, does not disable the 
+      default drag behavior of its parent cdkDrag element. 
+      You must explicitly disable dragging on the main element 
+      and re-enable it only when using the handle.
+      -->
+      <div *ngFor="let layoutItem of layout(); let i = index;trackBy: trackByFn"
+         cdkDrag  [cdkDragStartDelay]="{touch:1000,mouse:0}"
+        [cdkDragDisabled]="!isDraggable(layoutItem)"
         [class.form-flex-item]="isFlexItem()"
         [style.align-self]="(layoutItem.options || {})['align-self']"
         [style.flex-basis]="getFlexAttribute(layoutItem, 'flex-basis')"
         [style.flex-grow]="getFlexAttribute(layoutItem, 'flex-grow')"
         [style.flex-shrink]="getFlexAttribute(layoutItem, 'flex-shrink')"
         [style.order]="(layoutItem.options || {}).order"
-        [class.sortable-filter]="!isDraggable(layoutItem)"
-        [class.sortable-fixed]="isFixed(layoutItem)"
         >
+
+        <!-- workaround to disbale dragging of input fields -->
+        <!--
+        <div *ngIf="layoutItem?.dataType !='object'"  cdkDragHandle>
+         <p>Drag Handle {{layoutItem?.dataType}}</p>
+        </div>
+        -->
         <!--NB orderable directive is not used but has been left in for now and set to false
           otherwise the compiler won't recognize dataIndex and other dependent attributes
         -->
+        <!--
         <div 
           [dataIndex]="layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
           [layoutIndex]="(layoutIndex() || []).concat(i)"
           [layoutNode]="layoutItem"
           [orderable]="false"
-          [class.sortable-filter]="!isDraggable(layoutItem)"
-          [class.sortable-fixed]="isFixed(layoutItem)"
           >
           <select-framework-widget *ngIf="showWidget(layoutItem)"
             [dataIndex]="layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
             [layoutIndex]="(layoutIndex() || []).concat(i)"
             [layoutNode]="layoutItem"></select-framework-widget>
         </div>
+        -->
+      <select-framework-widget *ngIf="showWidget(layoutItem)"
+            [dataIndex]="getSelectFrameworkInputs(layoutItem,i).dataIndex"
+            [layoutIndex]="getSelectFrameworkInputs(layoutItem,i).layoutIndex"
+            [layoutNode]="getSelectFrameworkInputs(layoutItem,i).layoutNode">
+		  </select-framework-widget>
       </div>
     </div>
-    `, isInline: true, styles: ["[draggable=true]{transition:all .15s cubic-bezier(.4,0,.2,1)}[draggable=true]:hover{cursor:move;box-shadow:2px 2px 4px #0003;position:relative;z-index:10;margin:-1px 1px 1px -1px}[draggable=true].drag-target-top{box-shadow:0 -2px #000;position:relative;z-index:20}[draggable=true].drag-target-bottom{box-shadow:0 2px #000;position:relative;z-index:20}.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.SortablejsDirective, selector: "[nxtSortablejs]", inputs: ["nxtSortablejs", "sortablejsContainer", "config", "cloneFunction"], outputs: ["init"] }, { kind: "component", type: i3.SelectFrameworkComponent, selector: "select-framework-widget", inputs: ["layoutNode", "layoutIndex", "dataIndex"] }, { kind: "directive", type: i4.OrderableDirective, selector: "[orderable]", inputs: ["orderable", "layoutNode", "layoutIndex", "dataIndex"] }] }); }
+    `, isInline: true, styles: ["[draggable=true]{transition:all .15s cubic-bezier(.4,0,.2,1)}[draggable=true]:hover{cursor:move;box-shadow:2px 2px 4px #0003;position:relative;z-index:10;margin:-1px 1px 1px -1px}[draggable=true].drag-target-top{box-shadow:0 -2px #000;position:relative;z-index:20}[draggable=true].drag-target-bottom{box-shadow:0 2px #000;position:relative;z-index:20}.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: "component", type: i3.SelectFrameworkComponent, selector: "select-framework-widget", inputs: ["layoutNode", "layoutIndex", "dataIndex"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RootComponent, decorators: [{
             type: Component,
             args: [{ selector: 'root-widget', template: `
-    <div [class.flex-inherit]="true" #sortableContainter [nxtSortablejs]="layout()" [config]="sortableConfig" (init)="sortableInit($event)">
-      <div *ngFor="let layoutItem of layout(); let i = index"
+    <div cdkDropList (cdkDropListDropped)="drop($event)" 
+      [class.flex-inherit]="true"
+      [cdkDropListSortPredicate]="sortPredicate"
+    >
+      <!-- -for now left out
+      cdkDragHandle directive, by itself, does not disable the 
+      default drag behavior of its parent cdkDrag element. 
+      You must explicitly disable dragging on the main element 
+      and re-enable it only when using the handle.
+      -->
+      <div *ngFor="let layoutItem of layout(); let i = index;trackBy: trackByFn"
+         cdkDrag  [cdkDragStartDelay]="{touch:1000,mouse:0}"
+        [cdkDragDisabled]="!isDraggable(layoutItem)"
         [class.form-flex-item]="isFlexItem()"
         [style.align-self]="(layoutItem.options || {})['align-self']"
         [style.flex-basis]="getFlexAttribute(layoutItem, 'flex-basis')"
         [style.flex-grow]="getFlexAttribute(layoutItem, 'flex-grow')"
         [style.flex-shrink]="getFlexAttribute(layoutItem, 'flex-shrink')"
         [style.order]="(layoutItem.options || {}).order"
-        [class.sortable-filter]="!isDraggable(layoutItem)"
-        [class.sortable-fixed]="isFixed(layoutItem)"
         >
+
+        <!-- workaround to disbale dragging of input fields -->
+        <!--
+        <div *ngIf="layoutItem?.dataType !='object'"  cdkDragHandle>
+         <p>Drag Handle {{layoutItem?.dataType}}</p>
+        </div>
+        -->
         <!--NB orderable directive is not used but has been left in for now and set to false
           otherwise the compiler won't recognize dataIndex and other dependent attributes
         -->
+        <!--
         <div 
           [dataIndex]="layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
           [layoutIndex]="(layoutIndex() || []).concat(i)"
           [layoutNode]="layoutItem"
           [orderable]="false"
-          [class.sortable-filter]="!isDraggable(layoutItem)"
-          [class.sortable-fixed]="isFixed(layoutItem)"
           >
           <select-framework-widget *ngIf="showWidget(layoutItem)"
             [dataIndex]="layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])"
             [layoutIndex]="(layoutIndex() || []).concat(i)"
             [layoutNode]="layoutItem"></select-framework-widget>
         </div>
+        -->
+      <select-framework-widget *ngIf="showWidget(layoutItem)"
+            [dataIndex]="getSelectFrameworkInputs(layoutItem,i).dataIndex"
+            [layoutIndex]="getSelectFrameworkInputs(layoutItem,i).layoutIndex"
+            [layoutNode]="getSelectFrameworkInputs(layoutItem,i).layoutNode">
+		  </select-framework-widget>
       </div>
     </div>
-    `, standalone: false, styles: ["[draggable=true]{transition:all .15s cubic-bezier(.4,0,.2,1)}[draggable=true]:hover{cursor:move;box-shadow:2px 2px 4px #0003;position:relative;z-index:10;margin:-1px 1px 1px -1px}[draggable=true].drag-target-top{box-shadow:0 -2px #000;position:relative;z-index:20}[draggable=true].drag-target-bottom{box-shadow:0 2px #000;position:relative;z-index:20}.flex-inherit{display:inherit;flex-flow:inherit;flex-wrap:inherit;flex-direction:inherit;width:100%}\n"] }]
+    `, changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, styles: ["[draggable=true]{transition:all .15s cubic-bezier(.4,0,.2,1)}[draggable=true]:hover{cursor:move;box-shadow:2px 2px 4px #0003;position:relative;z-index:10;margin:-1px 1px 1px -1px}[draggable=true].drag-target-top{box-shadow:0 -2px #000;position:relative;z-index:20}[draggable=true].drag-target-bottom{box-shadow:0 2px #000;position:relative;z-index:20}.flex-inherit{display:inherit;flex-flow:inherit;flex-wrap:inherit;flex-direction:inherit;width:100%}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"root.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/widget-library/root.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, inject, input, OnDestroy, OnInit } from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { JsonSchemaFormService } from '../json-schema-form.service';\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: 'root-widget',\r\n  template: `\r\n    <div [class.flex-inherit]=\"true\" #sortableContainter [nxtSortablejs]=\"layout()\" [config]=\"sortableConfig\" (init)=\"sortableInit($event)\">\r\n      <div *ngFor=\"let layoutItem of layout(); let i = index\"\r\n        [class.form-flex-item]=\"isFlexItem()\"\r\n        [style.align-self]=\"(layoutItem.options || {})['align-self']\"\r\n        [style.flex-basis]=\"getFlexAttribute(layoutItem, 'flex-basis')\"\r\n        [style.flex-grow]=\"getFlexAttribute(layoutItem, 'flex-grow')\"\r\n        [style.flex-shrink]=\"getFlexAttribute(layoutItem, 'flex-shrink')\"\r\n        [style.order]=\"(layoutItem.options || {}).order\"\r\n        [class.sortable-filter]=\"!isDraggable(layoutItem)\"\r\n        [class.sortable-fixed]=\"isFixed(layoutItem)\"\r\n        >\r\n        <!--NB orderable directive is not used but has been left in for now and set to false\r\n          otherwise the compiler won't recognize dataIndex and other dependent attributes\r\n        -->\r\n        <div \r\n          [dataIndex]=\"layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])\"\r\n          [layoutIndex]=\"(layoutIndex() || []).concat(i)\"\r\n          [layoutNode]=\"layoutItem\"\r\n          [orderable]=\"false\"\r\n          [class.sortable-filter]=\"!isDraggable(layoutItem)\"\r\n          [class.sortable-fixed]=\"isFixed(layoutItem)\"\r\n          >\r\n          <select-framework-widget *ngIf=\"showWidget(layoutItem)\"\r\n            [dataIndex]=\"layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])\"\r\n            [layoutIndex]=\"(layoutIndex() || []).concat(i)\"\r\n            [layoutNode]=\"layoutItem\"></select-framework-widget>\r\n        </div>\r\n      </div>\r\n    </div>\r\n    `,\r\n  styles: [`\r\n    [draggable=true] {\r\n      transition: all 150ms cubic-bezier(.4, 0, .2, 1);\r\n    }\r\n    [draggable=true]:hover {\r\n      cursor: move;\r\n      box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);\r\n      position: relative; z-index: 10;\r\n      margin-top: -1px;\r\n      margin-left: -1px;\r\n      margin-right: 1px;\r\n      margin-bottom: 1px;\r\n    }\r\n    [draggable=true].drag-target-top {\r\n      box-shadow: 0 -2px 0 #000;\r\n      position: relative; z-index: 20;\r\n    }\r\n    [draggable=true].drag-target-bottom {\r\n      box-shadow: 0 2px 0 #000;\r\n      position: relative; z-index: 20;\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  standalone: false\r\n})\r\nexport class RootComponent implements OnInit, OnDestroy {\r\n\r\n\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  options: any;\r\n  readonly dataIndex = input<number[]>(undefined);\r\n  readonly layoutIndex = input<number[]>(undefined);\r\n  readonly layout = input<any[]>(undefined);\r\n  readonly isOrderable = input<boolean>(undefined);\r\n  readonly isFlexItem = input(false);\r\n\r\n  // @ViewChild('sortableContainter', {})\r\n  // sortableContainterElt: ElementRef;\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    delay: 1000,\r\n    delayOnTouchOnly: true,\r\n    onEnd: (/**Event*/evt)=> {\r\n      evt.newIndex // 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=evt.oldIndex;\r\n      let trgInd=evt.newIndex;\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, evt.oldIndex, evt.newIndex,false);\r\n      \r\n    },\r\n    onMove: function (/**Event*/evt, /**Event*/originalEvent) {\r\n      if(evt.related.classList.contains(\"sortable-fixed\")){\r\n       //console.log(evt.related);\r\n       return false;\r\n     }\r\n   }\r\n  }\r\n  private sortableOptionsSubscription: Subscription;\r\n  sortableInit(sortable) {\r\n    this.sortableObj = sortable;\r\n    //Sortable.utils.on(this.sortableObj.el,\"nulling\",(s)=>{console.log(\"event nulling sortablejs\")})\r\n    ///NB issue caused by sortablejs when it its destroyed\r\n    //this mainly affects checkboxes coupled with conditions\r\n    //-the value is rechecked\r\n    //-see https://github.com/SortableJS/Sortable/issues/1052#issuecomment-369613072\r\n    /* attempt to monkey patch sortable js \r\n    const originalMethod = sortable._nulling;\r\n    let zone=this.zone;\r\n    sortable._nulling=function() {\r\n      console.log(`pluginEvent 2 ${pluginEvent}`)\r\n            zone.runOutsideAngular(() => {\r\n              console.log(`pluginEvent3 ${pluginEvent}`)\r\n      pluginEvent('nulling', this);\r\n  \r\n      rootEl =\r\n      dragEl =\r\n      parentEl =\r\n      ghostEl =\r\n      nextEl =\r\n      cloneEl =\r\n      lastDownEl =\r\n      cloneHidden =\r\n  \r\n      tapEvt =\r\n      touchEvt =\r\n  \r\n      moved =\r\n      newIndex =\r\n      newDraggableIndex =\r\n      oldIndex =\r\n      oldDraggableIndex =\r\n  \r\n      lastTarget =\r\n      lastDirection =\r\n  \r\n      putSortable =\r\n      activeGroup =\r\n      Sortable.dragged =\r\n      Sortable.ghost =\r\n      Sortable.clone =\r\n      Sortable.active = null;\r\n  \r\n    \r\n        let el = this.el;\r\n        savedInputChecked.forEach(function (checkEl) {\r\n          if (el.contains(checkEl)) {\r\n            checkEl.checked = true;\r\n          }\r\n        });\r\n    \r\n        savedInputChecked.length =\r\n        lastDx =\r\n        lastDy = 0;\r\n\r\n      })\r\n\r\n    }.bind(sortable)\r\n    */\r\n  }\r\n\r\n  isDraggable(node: any): boolean {\r\n    let result=node.arrayItem && node.type !== '$ref' &&\r\n    node.arrayItemType === 'list' && this.isOrderable() !== false;\r\n    if (this.sortableObj) {\r\n      //this.sortableObj.option(\"disabled\",true);\r\n      //this.sortableObj.option(\"sort\",false);\r\n      //this.sortableObj.option(\"disabled\",!result);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  //TODO also need to think of other types such as button which can be\r\n  //created by an arbitrary layout\r\n  isFixed(node: any): boolean {\r\n    let result=node.type == '$ref';\r\n    return result;\r\n  }\r\n\r\n  // Set attributes for flexbox child\r\n  // (container attributes are set in 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  ngOnInit(): void {\r\n    // Subscribe to the draggable state\r\n    this.sortableOptionsSubscription = this.jsf.sortableOptions$.subscribe(\r\n      (optsValue) => {\r\n        if (this.sortableObj) {\r\n          Object.keys(optsValue).forEach(opt=>{\r\n            let optVal=optsValue[opt];\r\n            this.sortableObj.option(opt,optVal);\r\n          })\r\n          //this.sortableObj.option(\"disabled\",true);\r\n          //this.sortableObj.option(\"sort\",false);\r\n        }\r\n      }\r\n    );\r\n  }\r\n  ngOnDestroy(): void {\r\n    if (this.sortableOptionsSubscription) {\r\n      this.sortableOptionsSubscription.unsubscribe();\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"root.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/widget-library/root.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';\r\nimport { ChangeDetectionStrategy, Component, inject, input, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';\r\nimport { memoize } from 'lodash';\r\nimport { Subscription } from 'rxjs';\r\nimport { JsonSchemaFormService } from '../json-schema-form.service';\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: 'root-widget',\r\n  template: `\r\n    <div cdkDropList (cdkDropListDropped)=\"drop($event)\" \r\n      [class.flex-inherit]=\"true\"\r\n      [cdkDropListSortPredicate]=\"sortPredicate\"\r\n    >\r\n      <!-- -for now left out\r\n      cdkDragHandle directive, by itself, does not disable the \r\n      default drag behavior of its parent cdkDrag element. \r\n      You must explicitly disable dragging on the main element \r\n      and re-enable it only when using the handle.\r\n      -->\r\n      <div *ngFor=\"let layoutItem of layout(); let i = index;trackBy: trackByFn\"\r\n         cdkDrag  [cdkDragStartDelay]=\"{touch:1000,mouse:0}\"\r\n        [cdkDragDisabled]=\"!isDraggable(layoutItem)\"\r\n        [class.form-flex-item]=\"isFlexItem()\"\r\n        [style.align-self]=\"(layoutItem.options || {})['align-self']\"\r\n        [style.flex-basis]=\"getFlexAttribute(layoutItem, 'flex-basis')\"\r\n        [style.flex-grow]=\"getFlexAttribute(layoutItem, 'flex-grow')\"\r\n        [style.flex-shrink]=\"getFlexAttribute(layoutItem, 'flex-shrink')\"\r\n        [style.order]=\"(layoutItem.options || {}).order\"\r\n        >\r\n\r\n        <!-- workaround to disbale dragging of input fields -->\r\n        <!--\r\n        <div *ngIf=\"layoutItem?.dataType !='object'\"  cdkDragHandle>\r\n         <p>Drag Handle {{layoutItem?.dataType}}</p>\r\n        </div>\r\n        -->\r\n        <!--NB orderable directive is not used but has been left in for now and set to false\r\n          otherwise the compiler won't recognize dataIndex and other dependent attributes\r\n        -->\r\n        <!--\r\n        <div \r\n          [dataIndex]=\"layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])\"\r\n          [layoutIndex]=\"(layoutIndex() || []).concat(i)\"\r\n          [layoutNode]=\"layoutItem\"\r\n          [orderable]=\"false\"\r\n          >\r\n          <select-framework-widget *ngIf=\"showWidget(layoutItem)\"\r\n            [dataIndex]=\"layoutItem?.arrayItem ? (dataIndex() || []).concat(i) : (dataIndex() || [])\"\r\n            [layoutIndex]=\"(layoutIndex() || []).concat(i)\"\r\n            [layoutNode]=\"layoutItem\"></select-framework-widget>\r\n        </div>\r\n        -->\r\n      <select-framework-widget *ngIf=\"showWidget(layoutItem)\"\r\n            [dataIndex]=\"getSelectFrameworkInputs(layoutItem,i).dataIndex\"\r\n            [layoutIndex]=\"getSelectFrameworkInputs(layoutItem,i).layoutIndex\"\r\n            [layoutNode]=\"getSelectFrameworkInputs(layoutItem,i).layoutNode\">\r\n\t\t  </select-framework-widget>\r\n      </div>\r\n    </div>\r\n    `,\r\n  styles: [`\r\n    [draggable=true] {\r\n      transition: all 150ms cubic-bezier(.4, 0, .2, 1);\r\n    }\r\n    [draggable=true]:hover {\r\n      cursor: move;\r\n      box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);\r\n      position: relative; z-index: 10;\r\n      margin-top: -1px;\r\n      margin-left: -1px;\r\n      margin-right: 1px;\r\n      margin-bottom: 1px;\r\n    }\r\n    [draggable=true].drag-target-top {\r\n      box-shadow: 0 -2px 0 #000;\r\n      position: relative; z-index: 20;\r\n    }\r\n    [draggable=true].drag-target-bottom {\r\n      box-shadow: 0 2px 0 #000;\r\n      position: relative; z-index: 20;\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  changeDetection:ChangeDetectionStrategy.OnPush,\r\n  standalone: false\r\n})\r\nexport class RootComponent implements OnInit, OnDestroy,OnChanges {\r\n\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  options: any;\r\n  readonly dataIndex = input<number[]>(undefined);\r\n  readonly layoutIndex = input<number[]>(undefined);\r\n  readonly layout = input<any[]>(undefined);\r\n  readonly isOrderable = input<boolean>(undefined);\r\n  readonly isFlexItem = input(false);\r\n  readonly memoizationEnabled= input<boolean>(true);\r\n\r\n  dataChangesSubs:Subscription;\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    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    this.jsf.moveArrayItem(itemCtx, srcInd, trgInd,true);\r\n  }\r\n\r\n  isDraggable(node: any): boolean {\r\n    let result=node.arrayItem && node.type !== '$ref' &&\r\n    node.arrayItemType === 'list' && this.isOrderable() !== false\r\n    && node.type !=='submit'\r\n    return result;\r\n  }\r\n\r\n  //TODO also need to think of other types such as button which can be\r\n  //created by an arbitrary layout\r\n  isFixed(node: any): boolean {\r\n    let result=node.type == '$ref';\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Predicate function that disallows '$ref' item sorts\r\n   * NB declared as a var instead of a function \r\n   * like sortPredicate(index: number, item: CdkDrag<number>){..}\r\n   * since 'this' is bound to the draglist and doesn't reference the\r\n   * FlexLayoutRootComponent instance\r\n   */\r\n    //TODO also need to think of other types such as button which can be\r\n    //created by an arbitrary layout\r\n    //might not be needed added condition to [cdkDragDisabled]\r\n    sortPredicate=(index: number, item: CdkDrag<number>)=> {\r\n      let layoutItem=this.layout()[index];\r\n      let result=this.isDraggable(layoutItem);\r\n      //layoutItem.type != '$ref';\r\n      return result;\r\n    }\r\n\r\n  // Set attributes for flexbox child\r\n  // (container attributes are set in 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  //private selectframeworkInputCache = new Map<string, { dataIndex: any[], layoutIndex: any[], layoutNode: any }>();\r\n\r\n  //TODO review caching-if form field values change, the changes are not propagated\r\n\r\n  /*\r\n  getSelectFrameworkInputs(layoutItem: any, i: number) {\r\n    // Create a unique key based on the layoutItem and index\r\n    const cacheKey = `${layoutItem._id}-${i}`;\r\n  \r\n    // If the result is already in the cache, return it\r\n    if(this.enableCaching){\r\n      if (this.selectframeworkInputCache.has(cacheKey)) {\r\n        return this.selectframeworkInputCache.get(cacheKey);\r\n      }\r\n    }\r\n\r\n\r\n    // If not cached, calculate the values (assuming dataIndex() and layoutIndex() are functions)\r\n    const dataIndex = layoutItem?.arrayItem ? (this.dataIndex() || []).concat(i) : (this.dataIndex() || []);\r\n    const layoutIndex = (this.layoutIndex() || []).concat(i);\r\n\r\n    // Save the result in the cache\r\n    const result = { dataIndex, layoutIndex, layoutNode: layoutItem };\r\n    if(this.enableCaching){\r\n      this.selectframeworkInputCache.set(cacheKey, result);\r\n    }\r\n\r\n    return result;\r\n  }\r\n    */\r\n\r\n  private _getSelectFrameworkInputsRaw = (layoutItem: any, i: number) => {\r\n    const dataIndexValue = this.dataIndex() || [];\r\n    const layoutIndexValue = this.layoutIndex() || [];\r\n\r\n    return {\r\n      layoutNode: layoutItem,\r\n      layoutIndex: [...layoutIndexValue, i],\r\n      dataIndex: layoutItem?.arrayItem ? [...dataIndexValue, i] : dataIndexValue,\r\n    };\r\n  };\r\n\r\n  // Define a separate function to hold the memoized version\r\n  private _getSelectFrameworkInputsMemoized = memoize(\r\n    this._getSelectFrameworkInputsRaw,\r\n    (layoutItem: any, i: number) => {\r\n      const layoutItemKey = layoutItem?.id ?? JSON.stringify(layoutItem);\r\n      return `${layoutItemKey}-${i}`;\r\n    }\r\n  );\r\n\r\n  // This is the public function that the template calls\r\n  getSelectFrameworkInputs(layoutItem: any, i: number) {\r\n    if (this.memoizationEnabled) {\r\n      return this._getSelectFrameworkInputsMemoized(layoutItem, i);\r\n    } else {\r\n      return this._getSelectFrameworkInputsRaw(layoutItem, i);\r\n    }\r\n  }\r\n  trackByFn(index: number, item: any): any {\r\n    return item._id ?? index;\r\n  }\r\n\r\n  \r\n\r\n  /*\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    // If any of the input properties change, clear the cache\r\n    if (changes.dataIndex || changes.layoutIndex || changes.layout) {\r\n      this.selectframeworkInputCache?.clear(); // Clear the entire cache\r\n    }\r\n  }\r\n  */\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['layout'] || changes['dataIndex'] || changes['layoutIndex']) {\r\n      // Clear the entire cache of the memoized function\r\n      this._getSelectFrameworkInputsMemoized.cache.clear();\r\n    }\r\n  }\r\n\r\n\r\n  showWidget(layoutNode: any): boolean {\r\n    return this.jsf.evaluateCondition(layoutNode, this.dataIndex());\r\n  }\r\n  ngOnInit(): void {\r\n      if(this.memoizationEnabled){\r\n        this.jsf.dataChanges.subscribe((val)=>{\r\n          //this.selectframeworkInputCache?.clear();\r\n          this._getSelectFrameworkInputsMemoized.cache.clear();\r\n        })\r\n      }\r\n\r\n  }\r\n  ngOnDestroy(): void {\r\n      //this.selectframeworkInputCache?.clear()\r\n      //this.selectframeworkInputCache=null;\r\n      this._getSelectFrameworkInputsMemoized.cache.clear();\r\n      this.dataChangesSubs?.unsubscribe();\r\n  }\r\n  \r\n\r\n}\r\n"]}

package/esm2022/lib/widget-library/section.component.mjs

@@ -126,7 +126,7 @@ export class SectionComponent {
         [class]="options?.labelHelpBlockClass || ''"
         [innerHTML]="options?.description"></p>
       </div>
-    </fieldset>`, isInline: true, styles: [".legend{font-weight:700}.expandable>legend:before,.expandable>label:before{content:\"\\25b6\";padding-right:.3em;font-family:auto}.expanded>legend:before,.expanded>label:before{content:\"\\25bc\";padding-right:.2em}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.RootComponent, selector: "root-widget", inputs: ["dataIndex", "layoutIndex", "layout", "isOrderable", "isFlexItem"] }] }); }
+    </fieldset>`, isInline: true, styles: [".legend{font-weight:700}.expandable>legend:before,.expandable>label:before{content:\"\\25b6\";padding-right:.3em;font-family:auto}.expanded>legend:before,.expanded>label:before{content:\"\\25bc\";padding-right:.2em}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.RootComponent, selector: "root-widget", inputs: ["dataIndex", "layoutIndex", "layout", "isOrderable", "isFlexItem", "memoizationEnabled"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SectionComponent, decorators: [{
             type: Component,
@@ -193,4 +193,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
       </div>
     </fieldset>`, styles: [".legend{font-weight:700}.expandable>legend:before,.expandable>label:before{content:\"\\25b6\";padding-right:.3em;font-family:auto}.expanded>legend:before,.expanded>label:before{content:\"\\25bc\";padding-right:.2em}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"section.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/widget-library/section.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, inject, input } from '@angular/core';\r\nimport { JsonSchemaFormService } from '../json-schema-form.service';\r\n\r\n\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: '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\"\r\n        [class]=\"options?.labelHtmlClass || ''\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></label>\r\n      <root-widget \r\n        [dataIndex]=\"dataIndex()\"\r\n        [layout]=\"layoutNode().items\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [isOrderable]=\"options?.orderable\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\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')\"></root-widget>\r\n    </div>\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\"\r\n        [class]=\"options?.labelHtmlClass || ''\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></legend>\r\n      <div *ngIf=\"options?.messageLocation !== 'bottom'\">\r\n        <p *ngIf=\"options?.description\"\r\n        class=\"help-block\"\r\n        [class]=\"options?.labelHelpBlockClass || ''\"\r\n        [innerHTML]=\"options?.description\"></p>\r\n      </div>\r\n      <root-widget \r\n        [dataIndex]=\"dataIndex()\"\r\n        [layout]=\"layoutNode().items\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [isOrderable]=\"options?.orderable\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\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')\"></root-widget>\r\n      <div *ngIf=\"options?.messageLocation === 'bottom'\">\r\n        <p *ngIf=\"options?.description\"\r\n        class=\"help-block\"\r\n        [class]=\"options?.labelHelpBlockClass || ''\"\r\n        [innerHTML]=\"options?.description\"></p>\r\n      </div>\r\n    </fieldset>`,\r\n  styles: [`\r\n    .legend { font-weight: bold; }\r\n    .expandable > legend:before, .expandable > label:before  { content: '▶'; padding-right: .3em; font-family:auto }\r\n    .expanded > legend:before, .expanded > label:before  { content: '▼'; padding-right: .2em; }\r\n  `],\r\n})\r\nexport class SectionComponent implements OnInit {\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  options: any;\r\n  expanded = true;\r\n  containerType: string;\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 'fieldset': case 'array': case 'tab': case 'advancedfieldset':\r\n      case 'authfieldset': case 'optionfieldset': case 'selectfieldset':\r\n        this.containerType = 'fieldset';\r\n      break;\r\n      default: // 'div', 'flex', 'section', 'conditional', 'actions', 'tagsinput'\r\n        this.containerType = 'div';\r\n      break;\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 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    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"section.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/widget-library/section.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, inject, input } from '@angular/core';\r\nimport { JsonSchemaFormService } from '../json-schema-form.service';\r\n\r\n\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: '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\"\r\n        [class]=\"options?.labelHtmlClass || ''\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></label>\r\n      <root-widget \r\n        [dataIndex]=\"dataIndex()\"\r\n        [layout]=\"layoutNode().items\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [isOrderable]=\"options?.orderable\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\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')\"></root-widget>\r\n    </div>\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\"\r\n        [class]=\"options?.labelHtmlClass || ''\"\r\n        [innerHTML]=\"sectionTitle\"\r\n        (click)=\"toggleExpanded()\"></legend>\r\n      <div *ngIf=\"options?.messageLocation !== 'bottom'\">\r\n        <p *ngIf=\"options?.description\"\r\n        class=\"help-block\"\r\n        [class]=\"options?.labelHelpBlockClass || ''\"\r\n        [innerHTML]=\"options?.description\"></p>\r\n      </div>\r\n      <root-widget \r\n        [dataIndex]=\"dataIndex()\"\r\n        [layout]=\"layoutNode().items\"\r\n        [layoutIndex]=\"layoutIndex()\"\r\n        [isFlexItem]=\"getFlexAttribute('is-flex')\"\r\n        [isOrderable]=\"options?.orderable\"\r\n        [class.form-flex-column]=\"getFlexAttribute('flex-direction') === 'column'\"\r\n        [class.form-flex-row]=\"getFlexAttribute('flex-direction') === 'row'\"\r\n        [style.align-content]=\"getFlexAttribute('align-content')\"\r\n        [style.align-items]=\"getFlexAttribute('align-items')\"\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')\"></root-widget>\r\n      <div *ngIf=\"options?.messageLocation === 'bottom'\">\r\n        <p *ngIf=\"options?.description\"\r\n        class=\"help-block\"\r\n        [class]=\"options?.labelHelpBlockClass || ''\"\r\n        [innerHTML]=\"options?.description\"></p>\r\n      </div>\r\n    </fieldset>`,\r\n  styles: [`\r\n    .legend { font-weight: bold; }\r\n    .expandable > legend:before, .expandable > label:before  { content: '▶'; padding-right: .3em; font-family:auto }\r\n    .expanded > legend:before, .expanded > label:before  { content: '▼'; padding-right: .2em; }\r\n  `],\r\n})\r\nexport class SectionComponent implements OnInit {\r\n  private jsf = inject(JsonSchemaFormService);\r\n\r\n  options: any;\r\n  expanded = true;\r\n  containerType: string;\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\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 'fieldset': case 'array': case 'tab': case 'advancedfieldset':\r\n      case 'authfieldset': case 'optionfieldset': case 'selectfieldset':\r\n        this.containerType = 'fieldset';\r\n      break;\r\n      default: // 'div', 'flex', 'section', 'conditional', 'actions', 'tagsinput'\r\n        this.containerType = 'div';\r\n      break;\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 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    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/widget-library/select-framework.component.mjs

@@ -1,9 +1,10 @@
-import { Component, ViewContainerRef, inject, input, viewChild } from '@angular/core';
+import { ChangeDetectorRef, Component, ViewContainerRef, inject, input, viewChild } from '@angular/core';
 import { JsonSchemaFormService } from '../json-schema-form.service';
 import * as i0 from "@angular/core";
 export class SelectFrameworkComponent {
     constructor() {
         this.jsf = inject(JsonSchemaFormService);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
         this.newComponent = null;
         this.layoutNode = input(undefined);
         this.layoutIndex = input(undefined);
@@ -13,7 +14,7 @@ export class SelectFrameworkComponent {
     ngOnInit() {
         this.updateComponent();
     }
-    ngOnChanges() {
+    ngOnChanges(changes) {
         this.updateComponent();
     }
     updateComponent() {
@@ -24,9 +25,12 @@ export class SelectFrameworkComponent {
             //this.widgetContainer.createComponent<any>(this.jsf.framework)
         }
         if (this.newComponent) {
-            for (const input of ['layoutNode', 'layoutIndex', 'dataIndex']) {
-                this.newComponent.instance[input] = this[input];
+            for (const inp of ['layoutNode', 'layoutIndex', 'dataIndex']) {
+                //this.newComponent.instance[inp] = this[inp];
+                this.newComponent.setInput(inp, this[inp]());
             }
+            // Manually trigger change detection after updating inputs
+            //this.changeDetectorRef.detectChanges();
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectFrameworkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
@@ -40,4 +44,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     template: `<div #widgetContainer></div>`,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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