@wavemaker/app-ng-runtime 11.13.0-rc.6255 → 11.14.0-rc.226

package/components/input/dataset-aware-form/esm2022/dataset-aware-form.component.mjs

@@ -0,0 +1,307 @@
+import { Attribute, Inject, Injectable, Injector, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { $appDigest, AppDefaults, debounce, isDefined, isEqualWithFields, noop, toBoolean } from '@wm/core';
+import { ALLFIELDS, convertDataToObject, extractDataAsArray, getOrderedDataset, getUniqObjsByDataField, handleHeaderClick, toggleAllHeaders, transformFormData, transformDataWithKeys, groupData, ToDatePipe, WidgetConfig } from '@wm/components/base';
+import { BaseFormCustomComponent } from '@wm/components/input/base-form-custom';
+import { debounce as _debounce, find, isArray, isEmpty, isEqual, isNull, isObject, toString } from "lodash-es";
+import * as i0 from "@angular/core";
+export class DatasetAwareFormComponent extends BaseFormCustomComponent {
+    get modelByKey() {
+        return this._modelByKey;
+    }
+    // triggers on ngModel change. This function extracts the datavalue value.
+    set modelByKey(val) {
+        this.selectByKey(val);
+        // invoke on datavalue change.
+        this.invokeOnChange(this._modelByValue);
+    }
+    // @ts-ignore
+    get datavalue() {
+        return this._modelByValue;
+    }
+    // triggers on setting the datavalue. This function extracts the model value.
+    // @ts-ignore
+    set datavalue(val) {
+        if (this.multiple) {
+            val = extractDataAsArray(val);
+        }
+        this._modelByValue = val;
+        this.selectByValue(val);
+        // changes on the datavalue can be subscribed using listenToDatavalue
+        this.datavalue$.next(val);
+        // invoke on datavalue change.
+        this.invokeOnChange(val, undefined, true);
+    }
+    constructor(inj, config, explicitContext, groupby, initPromise) {
+        super(inj, config, explicitContext, initPromise);
+        this.groupby = groupby;
+        this.datasetItems = [];
+        this.acceptsArray = false; // set to true if proxyModel on widget accepts array type.
+        this.dataset$ = new Subject();
+        this.datavalue$ = new Subject();
+        this.allowempty = true;
+        this._debounceDatavalueUpdation = _debounce((values) => {
+            // if no item is found in datasetItems, wait untill the dataset updates by preserving the datavalue in toBeProcessedDatavalue.
+            if (!isDefined(this._modelByKey) || (isArray(this._modelByKey) && !this._modelByKey.length)) {
+                this.toBeProcessedDatavalue = values;
+                this._modelByValue = '';
+            }
+            else if (isDefined(this.toBeProcessedDatavalue)) {
+                // obtain the first array value when multiple is set to false.
+                // set the modelByValue only when undefined.
+                if (!isDefined(this._modelByValue)) {
+                    this._modelByValue = (!this.multiple && isArray(this.toBeProcessedDatavalue)) ? this.toBeProcessedDatavalue[0] : this.toBeProcessedDatavalue;
+                }
+                this.toBeProcessedDatavalue = undefined;
+            }
+            this.initDisplayValues();
+        }, 150);
+        this.datePipe = this.inj.get(ToDatePipe);
+        this.appDefaults = this.inj.get(AppDefaults);
+        this.binddisplayexpression = this.nativeElement.getAttribute('displayexpression.bind');
+        this.binddisplayimagesrc = this.nativeElement.getAttribute('displayimagesrc.bind');
+        this.binddisplaylabel = this.nativeElement.getAttribute('displaylabel.bind');
+        this._debouncedInitDatasetItems = debounce(() => {
+            this.initDatasetItems();
+            $appDigest();
+        }, 150);
+        this.handleHeaderClick = noop;
+        this.cancelLocaleChangeSubscription = this.getAppInstance().subscribe("locale-changed", () => {
+            this._debouncedInitDatasetItems();
+        });
+    }
+    /**
+     * This function sets the _datavalue value from the model and sets the selected flag when item is found.
+     * Here model is the value obtained from ngModel.
+     * @param keys represent the model.
+     */
+    selectByKey(keys) {
+        this.resetDatasetItems();
+        if (!this.datasetItems.length) {
+            return;
+        }
+        if (this.multiple && !isArray(keys)) {
+            keys = [keys];
+        }
+        // Set the _modelByKey to the modified keys.
+        this._modelByKey = keys;
+        if (this.multiple) {
+            this._modelByValue = [];
+            keys.forEach(key => {
+                const itemByKey = find(this.datasetItems, item => {
+                    // not triple equal, as the instance type can be different.
+                    // only value comparison should be done.
+                    return toString(item.key) === toString(key);
+                });
+                if (itemByKey) {
+                    itemByKey.selected = true;
+                    this._modelByValue = [...this._modelByValue, itemByKey.value];
+                }
+            });
+        }
+        else {
+            this._modelByValue = '';
+            const itemByKey = find(this.datasetItems, item => {
+                // not triple equal, as the instance type can be different.
+                // only value comparison should be done.
+                return toString(item.key) === toString(keys);
+            });
+            if (itemByKey) {
+                itemByKey.selected = true;
+                this._modelByValue = itemByKey.value;
+            }
+        }
+        this.initDisplayValues();
+    }
+    /**
+     * This function sets the _model value from the datavalue (selectedvalues) and sets the selected flag when item is found.
+     * datavalue is the default value or a value representing the displayField (for suppose: object in case of ALLFIELDS).
+     * If acceptsArray is true, the model always accepts an array.
+     * For example, select always accepts model as array whether multiple select is true or false.
+     * @param values represent the datavalue.
+     */
+    selectByValue(values) {
+        this.resetDatasetItems();
+        // if datavalue is not defined or empty then set the model as undefined.
+        if (!isDefined(values) || values === '' || isNull(values) || (values instanceof Array && !values.length)) {
+            this._modelByKey = undefined;
+            // do not return when allowempty is set to true.
+            if (!this.allowempty || !isDefined(values)) {
+                return;
+            }
+        }
+        if (this.acceptsArray && !isArray(values)) {
+            values = this.allowempty ? [values] : extractDataAsArray(values);
+        }
+        // preserve the datavalue if datasetItems are empty.
+        if (!this.datasetItems.length && isDefined(values)) {
+            this.toBeProcessedDatavalue = values;
+            return;
+        }
+        const filterField = this.datafield === ALLFIELDS ? 'dataObject' : 'key';
+        if (isArray(values)) {
+            this._modelByKey = [];
+            values.forEach(val => {
+                const itemByValue = find(this.datasetItems, item => {
+                    if (filterField === 'dataObject') {
+                        if (this.compareby && this.compareby.length) {
+                            return isEqualWithFields(item[filterField], val, this.compareby);
+                        }
+                    }
+                    return (isObject(item.value) ? isEqual(item.value, val) : (toString(item.value)).toLowerCase() === (toString(val)).toLowerCase());
+                });
+                if (itemByValue) {
+                    itemByValue.selected = true;
+                    this._modelByKey.push(itemByValue.key);
+                }
+            });
+        }
+        else {
+            this._modelByKey = undefined;
+            const itemByValue = find(this.datasetItems, item => {
+                if (filterField === 'dataObject') {
+                    if (this.compareby && this.compareby.length) {
+                        return isEqualWithFields(item[filterField], values, this.compareby);
+                    }
+                }
+                return (isObject(item.value) ? isEqual(item.value, values) : (toString(item.value)).toLowerCase() === (toString(values)).toLowerCase());
+            });
+            if (itemByValue) {
+                itemByValue.selected = true;
+                this._modelByKey = itemByValue.key;
+            }
+        }
+        // delaying the datavalue update as the widgets in liveform are having datavalue as undefined and not the default provided value
+        // because datavalue is updated later when new dataset is available.
+        this._debounceDatavalueUpdation(values);
+    }
+    // Updates the displayValue property.
+    initDisplayValues() {
+        const displayValues = [];
+        this.datasetItems.forEach(item => {
+            if (item.selected) {
+                displayValues.push(item.label);
+            }
+        });
+        this.displayValue = this.multiple ? displayValues : displayValues[0] || '';
+        if (this.viewParent.containerWidget && this.viewParent.containerWidget._isCustom)
+            this.viewParent.containerWidget.displayValue = this.displayValue.length ? this.displayValue : '';
+    }
+    // This function parses the dataset and extracts the displayOptions from parsed dataset.
+    initDatasetItems() {
+        if (!this.dataset || isEmpty(this.dataset)) {
+            this.datasetItems = [];
+            // notify the dataset listeners
+            this.dataset$.next(this.datasetItems);
+            return;
+        }
+        // convert any dataset to the object format.
+        const orderedDataset = getOrderedDataset(convertDataToObject(this.dataset), this.orderby);
+        if (this.usekeys) {
+            this.datasetItems = transformDataWithKeys(orderedDataset);
+        }
+        else {
+            const displayOptions = transformFormData(this.viewParent, orderedDataset, this.datafield, {
+                displayField: this.displayfield || this.displaylabel,
+                displayExpr: this.displayexpression,
+                bindDisplayExpr: this.binddisplayexpression || this.binddisplaylabel,
+                bindDisplayImgSrc: this.binddisplayimagesrc,
+                displayImgSrc: this.displayimagesrc
+            });
+            // get the unique objects out of the extracted data. Notify change in datasetItems using [...datasetItems] notation
+            this.datasetItems = [...getUniqObjsByDataField(displayOptions, this.datafield, this.displayfield || this.displaylabel, toBoolean(this.allowempty))];
+        }
+        this.postDatasetItemsInit();
+    }
+    // Once the datasetItems are ready, set the proxyModel by using datavalue.
+    postDatasetItemsInit() {
+        if (this.datasetItems.length && !this._defaultQueryInvoked) {
+            // use the latest of toBeProcessedDatavalue, datavalue
+            const _datavalue = isEmpty(this.toBeProcessedDatavalue) ? this.datavalue : this.toBeProcessedDatavalue;
+            this.selectByValue(_datavalue);
+        }
+        // notify the dataset listeners
+        this.dataset$.next(this.datasetItems);
+    }
+    // Reset the selected flag on datasetItems to false.
+    resetDatasetItems() {
+        this.datasetItems.forEach(item => item.selected = false);
+    }
+    setTemplate(partialName) {
+        this.content = partialName;
+        if (this.viewParent && this.viewParent.prefabName) {
+            this['prefabName'] = this.viewParent.prefabName;
+        }
+    }
+    getGroupedData() {
+        return this.datasetItems.length ? groupData(this, convertDataToObject(this.datasetItems), this.groupby, this.match, this.orderby, this.dateformat, this.datePipe, 'dataObject', this.appDefaults) : [];
+    }
+    datasetSubscription() {
+        const datasetSubscription = this.dataset$.subscribe(() => {
+            this.groupedData = this.getGroupedData();
+        });
+        this.registerDestroyListener(() => datasetSubscription.unsubscribe());
+    }
+    setGroupData() {
+        this.datasetSubscription();
+        // If groupby is set, get the groupedData from the datasetItems.
+        this.groupedData = this.getGroupedData();
+    }
+    onPropertyChange(key, nv, ov) {
+        super.onPropertyChange(key, nv, ov);
+        switch (key) {
+            case 'dataset':
+            case 'datafield':
+            case 'displayfield':
+            case 'displaylabel':
+            case 'displayexpression':
+            case 'orderby':
+            case 'usekeys':
+                this._debouncedInitDatasetItems();
+                break;
+            case 'required':
+            case 'datavalue':
+                this._onChange(this.datavalue);
+                break;
+            case 'groupby':
+            case 'match':
+                if (this.widgetType !== 'wm-search' && this.widgetType !== 'wm-chips') {
+                    this.setGroupData();
+                }
+                break;
+        }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.groupby && (this.widgetType !== 'wm-search' && this.widgetType !== 'wm-chips')) {
+            this.setGroupData();
+        }
+        // adding the handler for header click and toggle headers.
+        if (this.groupby && this.collapsible) {
+            this.handleHeaderClick = handleHeaderClick;
+            this.toggleAllHeaders = toggleAllHeaders.bind(undefined, this);
+        }
+    }
+    ngOnDestroy() {
+        if (this.cancelLocaleChangeSubscription) {
+            this.cancelLocaleChangeSubscription();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DatasetAwareFormComponent, deps: [{ token: i0.Injector }, { token: WidgetConfig }, { token: 'EXPLICIT_CONTEXT', optional: true }, { token: 'groupby', attribute: true }, { token: Promise }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DatasetAwareFormComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DatasetAwareFormComponent, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WidgetConfig]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['groupby']
+                }] }, { type: Promise }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dataset-aware-form.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/input/dataset-aware-form/src/dataset-aware-form.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Attribute, Inject, Injectable, Injector, OnDestroy, OnInit, Optional} from '@angular/core';\nimport {Subject} from 'rxjs';\nimport {$appDigest, AppDefaults, debounce, isDefined, isEqualWithFields, noop, toBoolean} from '@wm/core';\nimport { ALLFIELDS, convertDataToObject, DataSetItem, extractDataAsArray, getOrderedDataset, getUniqObjsByDataField, handleHeaderClick, toggleAllHeaders, transformFormData, transformDataWithKeys, groupData, ToDatePipe, IWidgetConfig, WidgetConfig } from '@wm/components/base';\nimport { BaseFormCustomComponent } from '@wm/components/input/base-form-custom';\nimport {debounce as _debounce, find, isArray, isEmpty, isEqual, isNull, isObject, toString} from \"lodash-es\";\n\n@Injectable()\nexport abstract class DatasetAwareFormComponent extends BaseFormCustomComponent implements OnInit, OnDestroy {\n    public dataset: any;\n    public datafield: string;\n    public displayfield: string;\n    public displaylabel: string;\n    public displayimagesrc: string;\n    public displayexpression: string;\n    public usekeys: boolean;\n    public orderby: string;\n    public multiple: boolean;\n    public readonly: boolean;\n    public content: string;\n    public collapsible: boolean;\n    public datePipe;\n\n    public handleHeaderClick: ($event) => void;\n    private toggleAllHeaders: void;\n    public appDefaults;\n\n    public binddisplayexpression: string;\n    public binddisplayimagesrc: string;\n    public binddisplaylabel: string;\n\n    public displayValue: Array<string> | string;\n\n    public datasetItems: DataSetItem[] = [];\n    public acceptsArray = false; // set to true if proxyModel on widget accepts array type.\n    protected dataset$ = new Subject();\n    protected datavalue$ = new Subject();\n\n    protected match: string;\n    protected dateformat: string;\n    public groupedData: any[];\n\n    protected _modelByKey: any;\n    public _modelByValue: any;\n    public _defaultQueryInvoked: boolean; // for search/chips if datavalue is obtained from the default n/w call then set to true and do not update the modelByKeys.\n\n    // this field contains the initial datavalue which needs to be processed once the dataset is available\n    public toBeProcessedDatavalue: any;\n    private readonly _debouncedInitDatasetItems: Function;\n    protected allowempty = true;\n    public compareby: any;\n\n    private cancelLocaleChangeSubscription;\n\n    public get modelByKey() {\n        return this._modelByKey;\n    }\n\n    // triggers on ngModel change. This function extracts the datavalue value.\n    public set modelByKey(val: any) {\n        this.selectByKey(val);\n\n        // invoke on datavalue change.\n        this.invokeOnChange(this._modelByValue);\n    }\n\n    // @ts-ignore\n    public get datavalue() {\n        return this._modelByValue;\n    }\n\n    // triggers on setting the datavalue. This function extracts the model value.\n    // @ts-ignore\n    public set datavalue(val: any) {\n        if (this.multiple) {\n            val = extractDataAsArray(val);\n        }\n        this._modelByValue = val;\n\n        this.selectByValue(val);\n\n        // changes on the datavalue can be subscribed using listenToDatavalue\n        this.datavalue$.next(val);\n\n        // invoke on datavalue change.\n        this.invokeOnChange(val, undefined, true);\n    }\n\n    protected constructor(inj: Injector,  @Inject(WidgetConfig) config: IWidgetConfig,\n                          @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any,\n                          @Attribute('groupby') public groupby?: string, initPromise?: Promise<any>) {\n        super(inj, config, explicitContext, initPromise);\n        this.datePipe = this.inj.get(ToDatePipe);\n        this.appDefaults = this.inj.get(AppDefaults);\n        this.binddisplayexpression = this.nativeElement.getAttribute('displayexpression.bind');\n        this.binddisplayimagesrc = this.nativeElement.getAttribute('displayimagesrc.bind');\n        this.binddisplaylabel = this.nativeElement.getAttribute('displaylabel.bind');\n\n        this._debouncedInitDatasetItems = debounce(() => {\n            this.initDatasetItems();\n            $appDigest();\n        }, 150);\n        this.handleHeaderClick = noop;\n\n        this.cancelLocaleChangeSubscription = this.getAppInstance().subscribe(\"locale-changed\", () => {\n            this._debouncedInitDatasetItems();\n        });\n    }\n\n    /**\n     * This function sets the _datavalue value from the model and sets the selected flag when item is found.\n     * Here model is the value obtained from ngModel.\n     * @param keys represent the model.\n     */\n    protected selectByKey(keys) {\n        this.resetDatasetItems();\n\n        if (!this.datasetItems.length) {\n            return;\n        }\n\n        if (this.multiple && !isArray(keys)) {\n            keys = [keys];\n        }\n\n        // Set the _modelByKey to the modified keys.\n        this._modelByKey = keys;\n\n        if (this.multiple) {\n            this._modelByValue = [];\n            keys.forEach(key => {\n                const itemByKey = find(this.datasetItems, item => {\n                    // not triple equal, as the instance type can be different.\n                    // only value comparison should be done.\n                    return toString(item.key) === toString(key);\n                });\n                if (itemByKey) {\n                    itemByKey.selected = true;\n                    this._modelByValue = [...this._modelByValue, itemByKey.value];\n                }\n            });\n        } else {\n            this._modelByValue = '';\n            const itemByKey = find(this.datasetItems, item => {\n                // not triple equal, as the instance type can be different.\n                // only value comparison should be done.\n                return toString(item.key) === toString(keys);\n            });\n            if (itemByKey) {\n                itemByKey.selected = true;\n                this._modelByValue = itemByKey.value;\n            }\n        }\n        this.initDisplayValues();\n    }\n\n    /**\n     * This function sets the _model value from the datavalue (selectedvalues) and sets the selected flag when item is found.\n     * datavalue is the default value or a value representing the displayField (for suppose: object in case of ALLFIELDS).\n     * If acceptsArray is true, the model always accepts an array.\n     * For example, select always accepts model as array whether multiple select is true or false.\n     * @param values represent the datavalue.\n     */\n    protected selectByValue(values: Array<any> | any) {\n        this.resetDatasetItems();\n\n        // if datavalue is not defined or empty then set the model as undefined.\n        if (!isDefined(values) || values === '' || isNull(values) || (values instanceof Array && !values.length)) {\n            this._modelByKey = undefined;\n            // do not return when allowempty is set to true.\n            if (!this.allowempty || !isDefined(values)) {\n                return;\n            }\n        }\n\n        if (this.acceptsArray && !isArray(values)) {\n            values = this.allowempty ? [values] : extractDataAsArray(values);\n        }\n\n        // preserve the datavalue if datasetItems are empty.\n        if (!this.datasetItems.length && isDefined(values)) {\n            this.toBeProcessedDatavalue = values;\n            return;\n        }\n\n        const filterField = this.datafield === ALLFIELDS ? 'dataObject' : 'key';\n\n        if (isArray(values)) {\n            this._modelByKey = [];\n            values.forEach(val => {\n                const itemByValue = find(this.datasetItems, item => {\n                    if (filterField === 'dataObject') {\n                        if (this.compareby && this.compareby.length) {\n                            return isEqualWithFields(item[filterField], val, this.compareby);\n                        }\n                    }\n                    return (isObject(item.value) ? isEqual(item.value, val) : (toString(item.value)).toLowerCase() === (toString(val)).toLowerCase());\n                });\n                if (itemByValue) {\n                    itemByValue.selected = true;\n                    this._modelByKey.push(itemByValue.key);\n                }\n            });\n        } else {\n            this._modelByKey = undefined;\n            const itemByValue = find(this.datasetItems, item => {\n                if (filterField === 'dataObject') {\n                    if (this.compareby && this.compareby.length) {\n                        return isEqualWithFields(item[filterField], values, this.compareby);\n                    }\n                }\n                return (isObject(item.value) ? isEqual(item.value, values) : (toString(item.value)).toLowerCase() === (toString(values)).toLowerCase());\n            });\n            if (itemByValue) {\n                itemByValue.selected = true;\n                this._modelByKey = itemByValue.key;\n            }\n        }\n        // delaying the datavalue update as the widgets in liveform are having datavalue as undefined and not the default provided value\n        // because datavalue is updated later when new dataset is available.\n        this._debounceDatavalueUpdation(values);\n    }\n\n    protected readonly _debounceDatavalueUpdation = _debounce((values) => {\n        // if no item is found in datasetItems, wait untill the dataset updates by preserving the datavalue in toBeProcessedDatavalue.\n        if (!isDefined(this._modelByKey) || (isArray(this._modelByKey) && !this._modelByKey.length)) {\n            this.toBeProcessedDatavalue = values;\n            this._modelByValue = '';\n        } else if (isDefined(this.toBeProcessedDatavalue)) {\n            // obtain the first array value when multiple is set to false.\n            // set the modelByValue only when undefined.\n            if (!isDefined(this._modelByValue)) {\n                this._modelByValue = (!this.multiple && isArray(this.toBeProcessedDatavalue)) ? this.toBeProcessedDatavalue[0] : this.toBeProcessedDatavalue;\n            }\n            this.toBeProcessedDatavalue = undefined;\n        }\n\n        this.initDisplayValues();\n    }, 150);\n\n    // Updates the displayValue property.\n    protected initDisplayValues() {\n        const displayValues = [];\n        this.datasetItems.forEach(item => {\n            if (item.selected) {\n                displayValues.push(item.label);\n            }\n        });\n\n        this.displayValue = this.multiple ? displayValues : displayValues[0] || '';\n        if(this.viewParent.containerWidget && this.viewParent.containerWidget._isCustom)\n            this.viewParent.containerWidget.displayValue = this.displayValue.length ? this.displayValue : '';\n    }\n\n    // This function parses the dataset and extracts the displayOptions from parsed dataset.\n    protected initDatasetItems() {\n        if (!this.dataset || isEmpty(this.dataset)) {\n            this.datasetItems = [];\n            // notify the dataset listeners\n            this.dataset$.next(this.datasetItems);\n            return;\n        }\n\n        // convert any dataset to the object format.\n        const orderedDataset = getOrderedDataset(convertDataToObject(this.dataset), this.orderby);\n\n        if (this.usekeys) {\n            this.datasetItems = transformDataWithKeys(orderedDataset);\n        } else {\n            const displayOptions = transformFormData(this.viewParent, orderedDataset, this.datafield, {\n                displayField: this.displayfield || this.displaylabel,\n                displayExpr: this.displayexpression,\n                bindDisplayExpr: this.binddisplayexpression || this.binddisplaylabel,\n                bindDisplayImgSrc: this.binddisplayimagesrc,\n                displayImgSrc: this.displayimagesrc\n            });\n            // get the unique objects out of the extracted data. Notify change in datasetItems using [...datasetItems] notation\n            this.datasetItems = [...getUniqObjsByDataField(displayOptions, this.datafield, this.displayfield || this.displaylabel, toBoolean(this.allowempty))];\n        }\n\n        this.postDatasetItemsInit();\n    }\n\n    // Once the datasetItems are ready, set the proxyModel by using datavalue.\n    protected postDatasetItemsInit() {\n        if (this.datasetItems.length && !this._defaultQueryInvoked) {\n            // use the latest of toBeProcessedDatavalue, datavalue\n            const _datavalue = isEmpty(this.toBeProcessedDatavalue) ? this.datavalue : this.toBeProcessedDatavalue;\n            this.selectByValue(_datavalue);\n        }\n        // notify the dataset listeners\n        this.dataset$.next(this.datasetItems);\n    }\n\n    // Reset the selected flag on datasetItems to false.\n    protected resetDatasetItems() {\n        this.datasetItems.forEach(item => item.selected = false);\n    }\n\n    protected setTemplate(partialName) {\n        this.content = partialName;\n        if (this.viewParent && this.viewParent.prefabName) {\n            this['prefabName'] = this.viewParent.prefabName;\n        }\n    }\n\n\n    private getGroupedData() {\n        return this.datasetItems.length ? groupData(this, convertDataToObject(this.datasetItems), this.groupby, this.match, this.orderby, this.dateformat, this.datePipe, 'dataObject', this.appDefaults) : [];\n    }\n\n    private datasetSubscription() {\n        const datasetSubscription = this.dataset$.subscribe(() => {\n            this.groupedData = this.getGroupedData();\n        });\n        this.registerDestroyListener(() => datasetSubscription.unsubscribe());\n    }\n\n    protected setGroupData() {\n        this.datasetSubscription();\n        // If groupby is set, get the groupedData from the datasetItems.\n        this.groupedData = this.getGroupedData();\n    }\n\n\n    onPropertyChange(key: string, nv: any, ov?: any) {\n        super.onPropertyChange(key, nv, ov);\n        switch (key) {\n            case 'dataset':\n            case 'datafield':\n            case 'displayfield':\n            case 'displaylabel':\n            case 'displayexpression':\n            case 'orderby':\n            case 'usekeys':\n                this._debouncedInitDatasetItems();\n                break;\n            case 'required':\n            case 'datavalue':\n                this._onChange(this.datavalue);\n                break;\n            case 'groupby':\n            case 'match':\n                if (this.widgetType !== 'wm-search' && this.widgetType !== 'wm-chips') {\n                    this.setGroupData();\n                }\n            break;\n        }\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n        if (this.groupby && (this.widgetType !== 'wm-search' && this.widgetType !== 'wm-chips')) {\n            this.setGroupData();\n        }\n        // adding the handler for header click and toggle headers.\n        if (this.groupby && this.collapsible) {\n            this.handleHeaderClick = handleHeaderClick;\n            this.toggleAllHeaders = toggleAllHeaders.bind(undefined, this);\n        }\n    }\n\n    ngOnDestroy() {\n        if(this.cancelLocaleChangeSubscription) {\n            this.cancelLocaleChangeSubscription();\n        }\n    }\n}\n"]}

package/components/input/dataset-aware-form/esm2022/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3dpZGdldHMvaW5wdXQvZGF0YXNldC1hd2FyZS1mb3JtL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/components/input/dataset-aware-form/esm2022/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './dataset-aware-form.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvd2lkZ2V0cy9pbnB1dC9kYXRhc2V0LWF3YXJlLWZvcm0vc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0YXNldC1hd2FyZS1mb3JtLmNvbXBvbmVudCc7XG4iXX0=