@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/data/form/esm2022/live-form/live-form.directive.mjs

@@ -0,0 +1,502 @@
+import { Directive, Inject, Optional, Self, Attribute, HostListener } from '@angular/core';
+import { $appDigest, AbstractDialogService, DataSource, DataType, debounce, getClonedObject, getFiles, getValidDateObject, isDateTimeType, isDefined, isEmptyObject } from '@wm/core';
+import { ALLFIELDS, applyFilterOnField, fetchRelatedFieldData, getDistinctValuesForField, isDataSetWidget, Live_Operations, parseValueByType, performDataOperation, ToDatePipe } from '@wm/components/base';
+import { LiveTableComponent } from '@wm/components/data/live-table';
+import { registerLiveFormProps } from '../form.props';
+import { FormComponent } from '../form.component';
+import { forEach, fromPairs, get, isEmpty, isEqual, isString, map, some, split } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/components/data/live-table";
+import * as i2 from "@wm/components/base";
+import * as i3 from "@wm/core";
+const isTimeType = field => field.widgettype === DataType.TIME || (field.type === DataType.TIME && !field.widgettype);
+const getValidTime = val => {
+    if (val) {
+        const date = (new Date()).toDateString();
+        return (new Date(`${date} ${val}`)).getTime();
+    }
+    return undefined;
+};
+export class LiveFormDirective {
+    static { this.initializeProps = registerLiveFormProps(); }
+    onKeydownHandler(event) {
+        this._triggeredByUser = true;
+    }
+    constructor(form, liveTable, datePipe, dialogService, formlayout) {
+        this.form = form;
+        this.datePipe = datePipe;
+        this.dialogService = dialogService;
+        this._debouncedSavePrevDataValues = debounce(() => {
+            this.savePrevDataValues();
+        }, 250);
+        // If parent live table is present and this form is first child of live table, set this form instance on livetable
+        if (liveTable) {
+            if (!this.form.parentForm) {
+                this.form._liveTableParent = liveTable;
+            }
+            this.form.isLayoutDialog = liveTable.isLayoutDialog;
+            liveTable.onFormReady(this.form);
+        }
+        else {
+            this.form.isLayoutDialog = formlayout === 'dialog';
+        }
+        // CUD operations
+        form.cancel = this.cancel.bind(this);
+        form.reset = this.reset.bind(this);
+        form.delete = this.delete.bind(this);
+        form.save = this.save.bind(this);
+        form.saveAndNew = this.saveAndNew.bind(this);
+        form.saveAndView = this.saveAndView.bind(this);
+        form.setPrimaryKey = this.setPrimaryKey.bind(this);
+        form.constructDataObject = this.constructDataObject.bind(this);
+        form.changeDataObject = this.setFormData.bind(this);
+        form.setFormData = this.setFormData.bind(this);
+        form.findOperationType = this.findOperationType.bind(this);
+        form.clearData = this.clearData.bind(this);
+        form.onFieldDefaultValueChange = this.onFieldDefaultValueChange.bind(this);
+        form.onDataSourceChange = this.onDataSourceChange.bind(this);
+        form.onFieldValueChange = this.onFieldValueChange.bind(this);
+        form.submitForm = this.submitForm.bind(this);
+        form.form_registerFormFields = form.registerFormFields;
+        form.registerFormFields = this.registerFormFields.bind(this);
+    }
+    /*
+    WMS:18583
+    Overriding 'registerFormFields' for liveForms,
+    On Each field added, check if the dataSource is updated or not
+    if the field is added after the dataSource is updated at LiveForm, retrigger
+    */
+    registerFormFields(formField) {
+        const formFields = this.form.getFormFields();
+        this.form.form_registerFormFields(formField);
+        if (this.form.isDataSourceUpdated) {
+            this._updateFieldOnDataSourceChange(formField, formFields);
+        }
+    }
+    _updateFieldOnDataSourceChange(field, formFields) {
+        if (!field.isDataSetBound && isDataSetWidget(field.widgettype)) {
+            if (field['is-related']) {
+                field.isDataSetBound = true;
+                fetchRelatedFieldData(this.form.datasource, field.widget, {
+                    relatedField: field.key,
+                    datafield: ALLFIELDS,
+                    widget: 'widgettype',
+                });
+            }
+            else {
+                getDistinctValuesForField(this.form.datasource, field.widget, {
+                    widget: 'widgettype',
+                    enableemptyfilter: this.form.enableemptyfilter
+                });
+                applyFilterOnField(this.form.datasource, field.widget, formFields, field.value, { isFirst: true });
+            }
+        }
+    }
+    onDataSourceChange() {
+        if (get(this.form.formFields, 'length')) {
+            this.form.isDataSourceUpdated = true;
+        }
+        const formFields = this.form.getFormFields();
+        formFields.forEach(field => {
+            this._updateFieldOnDataSourceChange(field, formFields);
+        });
+    }
+    onFieldDefaultValueChange(field, nv) {
+        // In Edit, do  not set default values
+        if (this.form.operationType === 'update') {
+            return;
+        }
+        // Set the default value only if it exists.
+        if (isDefined(nv) && nv !== null && nv !== '' && nv !== 'null') {
+            field.value = parseValueByType(nv, field.type, field.widgettype, field.trailingzero);
+        }
+        else {
+            field.value = undefined;
+        }
+        // WMS-22434: For default value set on individual form fields, do not mark the form as dirty.
+        if (this.form.dirty && !this._triggeredByUser) {
+            this.form.markAsPristine();
+        }
+        this._debouncedSavePrevDataValues();
+    }
+    onFieldValueChange(field, nv) {
+        applyFilterOnField(this.form.datasource, field.widget, this.form.formFields, nv);
+    }
+    getBlobURL(dataObj, key, value) {
+        let href = '';
+        let primaryKeys;
+        let primaryKey;
+        if (value === null || value === undefined || !this.form.datasource) {
+            return href;
+        }
+        primaryKeys = this.form.datasource.execute(DataSource.Operation.GET_PRIMARY_KEY) || [];
+        primaryKey = dataObj[primaryKeys[0]];
+        href += this.form.datasource.execute(DataSource.Operation.GET_BLOB_URL, {
+            primaryValue: primaryKey,
+            columnName: key
+        });
+        href += '?' + Math.random();
+        return href;
+    }
+    setFormData(dataObj, formFields) {
+        if (!dataObj) {
+            return;
+        }
+        formFields = formFields || this.form.formFields;
+        formFields.forEach(field => {
+            const value = get(dataObj, field.key || field.name);
+            if (isTimeType(field)) {
+                field.value = getValidTime(value);
+            }
+            else if (field.type === DataType.BLOB) {
+                this.form.resetFileUploadWidget(field, true);
+                field.href = this.getBlobURL(dataObj, field.key, value);
+                field.value = isString(value) ? '' : value;
+            }
+            else {
+                this.form.setFieldValue(field, dataObj);
+            }
+        });
+        this.savePrevDataValues();
+        this.form.constructDataObject();
+    }
+    onDataSourceUpdate(response, newForm, updateMode) {
+        if (newForm) {
+            this.form.new();
+        }
+        else {
+            this.form.setFormData(response);
+            this.closeDialog();
+        }
+        this.form.isUpdateMode = isDefined(updateMode) ? updateMode : true;
+    }
+    savePrevformFields() {
+        this.form.prevformFields = getClonedObject(this.form.formFields.map(field => {
+            return {
+                'key': field.key,
+                'type': field.type,
+                'widgettype': field.widgettype,
+                'outputformat': field.outputformat,
+                'value': field.value
+            };
+        }));
+    }
+    getPrevformFields() {
+        this.form.formFields.map(field => {
+            const prevField = this.form.prevformFields.find(pField => pField.key === field.key);
+            field.value = prevField.value;
+        });
+    }
+    getDataObject() {
+        if (this.form.operationType === Live_Operations.INSERT) {
+            return {};
+        }
+        if (isDefined(this.form.prevDataObject) && !isEmptyObject(this.form.prevDataObject)) {
+            return getClonedObject(this.form.prevDataObject);
+        }
+        return getClonedObject(this.form.formdata || {});
+    }
+    constructDataObject(isPreviousData) {
+        const dataObject = this.getDataObject();
+        const formName = this.form.name;
+        let formFields;
+        formFields = isPreviousData ? this.form.prevformFields : this.form.getFormFields();
+        formFields.forEach(field => {
+            let dateTime, fieldValue;
+            const fieldTarget = split(field.key, '.');
+            const fieldName = fieldTarget[0] || field.key;
+            /*collect the values from the fields and construct the object*/
+            /*Format the output of date time widgets to the given output format*/
+            if ((field.widgettype && isDateTimeType(field.widgettype)) || isDateTimeType(field.type)) {
+                if (field.value) {
+                    dateTime = getValidDateObject(field.value);
+                    if (field.outputformat === DataType.TIMESTAMP || field.type === DataType.TIMESTAMP) {
+                        fieldValue = field.value ? dateTime : null;
+                    }
+                    else if (field.outputformat) {
+                        fieldValue = this.datePipe.transform(dateTime, field.outputformat);
+                    }
+                    else {
+                        fieldValue = field.value;
+                    }
+                }
+                else {
+                    fieldValue = undefined;
+                }
+            }
+            else if (field.type === DataType.BLOB) {
+                fieldValue = getFiles(formName, fieldName + '_formWidget', field.multiple);
+            }
+            else if (field.type === DataType.LIST) {
+                fieldValue = field.value || undefined;
+            }
+            else {
+                fieldValue = (field.value === null || field.value === '') ? undefined : field.value;
+            }
+            if (fieldTarget.length === 1) {
+                dataObject[fieldName] = fieldValue;
+            }
+            else {
+                dataObject[fieldName] = dataObject[fieldName] || {};
+                dataObject[fieldName][fieldTarget[1]] = fieldValue;
+            }
+        });
+        if (!isPreviousData) {
+            this.form.updateFormDataOutput(dataObject);
+            return this.form.dataoutput;
+        }
+        return dataObject;
+    }
+    setPrimaryKey(fieldName) {
+        /*Store the primary key of data*/
+        this.form.primaryKey = this.form.primaryKey || [];
+        if (this.form.primaryKey.indexOf(fieldName) === -1) {
+            this.form.primaryKey.push(fieldName);
+        }
+    }
+    findOperationType() {
+        let operation;
+        let isPrimary = false;
+        const sourceOperation = this.form.datasource && this.form.datasource.execute(DataSource.Operation.GET_OPERATION_TYPE);
+        if (sourceOperation && sourceOperation !== 'read') {
+            return sourceOperation;
+        }
+        /*If OperationType is not set then based on the formdata object return the operation type,
+            this case occurs only if the form is outside a livegrid*/
+        /*If the formdata object has primary key value then return update else insert*/
+        if (this.form.primaryKey && !isEmpty(this.form.formdata)) {
+            /*If only one column is primary key*/
+            if (this.form.primaryKey.length === 1) {
+                if (this.form.formdata[this.form.primaryKey[0]]) {
+                    operation = Live_Operations.UPDATE;
+                }
+                /*If only no column is primary key*/
+            }
+            else if (this.form.primaryKey.length === 0) {
+                forEach(this.form.formdata, (value) => {
+                    if (value) {
+                        isPrimary = true;
+                    }
+                });
+                if (isPrimary) {
+                    operation = Live_Operations.UPDATE;
+                }
+                /*If multiple columns are primary key*/
+            }
+            else {
+                isPrimary = some(this.form.primaryKey, (primaryKey) => {
+                    if (this.form.formdata[primaryKey]) {
+                        return true;
+                    }
+                });
+                if (isPrimary) {
+                    operation = Live_Operations.UPDATE;
+                }
+            }
+        }
+        return operation || Live_Operations.INSERT;
+    }
+    getPrevDataValues() {
+        const prevDataValues = fromPairs(map(this.form.prevDataValues, (item) => {
+            return [item.key, item.value];
+        })); // Convert of array of values to an object
+        this.form.formFields.forEach(field => {
+            field.value = prevDataValues[field.key] || '';
+            field.resetDisplayInput();
+        });
+        return prevDataValues;
+    }
+    savePrevDataValues() {
+        this.form.prevDataValues = this.form.formFields.map((obj) => {
+            return { 'key': obj.key, 'value': obj.value };
+        });
+    }
+    clearData() {
+        this.form.toggleMessage(false);
+        this.form.emptyDataModel();
+    }
+    setReadonlyFields() {
+        this.form.formFields.forEach(field => {
+            field.setReadOnlyState();
+        });
+    }
+    reset() {
+        let prevDataValues;
+        this.form.resetFormState();
+        prevDataValues = this.getPrevDataValues();
+        this.form.formFields.forEach(field => {
+            if (field.type === DataType.BLOB || field.widgettype === 'upload') {
+                this.form.resetFileUploadWidget(field, true);
+                field.href = this.getBlobURL(prevDataValues, field.key, field.value);
+            }
+            field.nativeElement.querySelector('input')?.removeAttribute('aria-invalid');
+        });
+        this.form.constructDataObject();
+    }
+    closeDialog() {
+        if (this.form.isLayoutDialog) {
+            this.dialogService.close(this.form.dialogId);
+        }
+    }
+    cancel() {
+        this.form.clearMessage();
+        this.form.isUpdateMode = false;
+        this.form.reset();
+        /*Show the previous selected data*/
+        if (this.form.isSelected) {
+            this.getPrevformFields();
+        }
+        this.form.isUpdateMode = false;
+        if (this.form._liveTableParent) {
+            this.form._liveTableParent.onCancel();
+        }
+        else {
+            /*
+              WMS-18759: dialog close is calling twice and dialog onHidden subscription is calling once from the library
+              due to this if we have another dialog inside liveform and if we click on cancel of second dialog the library
+              subscription is calling for both the dialogs.
+             */
+            this.closeDialog();
+        }
+        $appDigest();
+    }
+    delete(callBackFn) {
+        this.form.resetFormState();
+        this.form.operationType = Live_Operations.DELETE;
+        this.form.prevDataObject = getClonedObject(this.form.formdata || {});
+        this.form.save(undefined, undefined, undefined, callBackFn);
+    }
+    // Function use to save the form and open new form after save
+    saveAndNew() {
+        this.save(undefined, true, true);
+    }
+    // Function use to save the form and open new form after save
+    saveAndView() {
+        this.save(undefined, false);
+    }
+    submitForm($event) {
+        this.save($event);
+    }
+    save(event, updateMode, newForm) {
+        if (!this.form.datasource) {
+            return;
+        }
+        let data, prevData, operationType, isValid;
+        const requestData = {};
+        operationType = this.form.operationType = this.form.operationType || this.findOperationType();
+        // Disable the form submit if form is in invalid state.
+        if (this.form.validateFieldsOnSubmit()) {
+            return;
+        }
+        data = getClonedObject(this.form.constructDataObject());
+        prevData = this.form.prevformFields ? this.form.constructDataObject(true) : data;
+        try {
+            isValid = this.form.invokeEventCallback('beforeservicecall', { $event: event, $operation: this.form.operationType, $data: data, options: requestData });
+            if (isValid === false) {
+                return;
+            }
+            if (isValid && isValid.error) {
+                this.form.toggleMessage(true, isValid.error, 'error');
+                return;
+            }
+        }
+        catch (err) {
+            if (err.message === 'Abort') {
+                return;
+            }
+        }
+        // If operation is update, form is not touched and current data and previous data is same, Show no changes detected message
+        if (this.form.operationType === Live_Operations.UPDATE && this.form.ngform && this.form.ngform.pristine &&
+            (this.form.isSelected && isEqual(data, prevData))) {
+            this.form.toggleMessage(true, this.form.appLocale.MESSAGE_NO_CHANGES, 'info', '');
+            $appDigest();
+            return;
+        }
+        requestData.row = data;
+        requestData.transform = true;
+        requestData.skipNotification = true;
+        if (operationType === Live_Operations.UPDATE) {
+            requestData.rowData = this.form.formdata;
+            requestData.prevData = prevData;
+        }
+        performDataOperation(this.form.datasource, requestData, {
+            operationType: operationType
+        }).then((response) => {
+            const msg = operationType === Live_Operations.INSERT ? this.form.insertmessage : (operationType === Live_Operations.UPDATE ?
+                this.form.updatemessage : this.form.deletemessage);
+            let result;
+            if (operationType === Live_Operations.DELETE) {
+                result = requestData.row;
+                this.form.emptyDataModel();
+                this.form.prevDataValues = [];
+                this.form.isSelected = false;
+            }
+            else {
+                result = response;
+            }
+            if (!this.form.onSuccess) {
+                this.form.toggleMessage(true, msg, 'success');
+            }
+            if (this.form._liveTableParent) {
+                // highlight the current updated row
+                this.form._liveTableParent.onResult(operationType, response, newForm, updateMode);
+            }
+            else {
+                /*get updated data without refreshing page*/
+                this.form.datasource.execute(DataSource.Operation.LIST_RECORDS, {
+                    'skipToggleState': true
+                });
+                this.onDataSourceUpdate(response, newForm, updateMode);
+            }
+            return {
+                'result': result,
+                'status': true
+            };
+        }, (error) => {
+            if (!this.form.onError) {
+                this.form.toggleMessage(true, error, 'error');
+            }
+            $appDigest();
+            return {
+                'result': error,
+                'status': false
+            };
+        }).then(response => {
+            // reset the form to pristine state
+            this.form.resetFormState();
+            this.form.onResultCb(response.result, response.status, event);
+        });
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Cancel debounced function
+        if (this._debouncedSavePrevDataValues && this._debouncedSavePrevDataValues.cancel) {
+            this._debouncedSavePrevDataValues.cancel();
+            this._debouncedSavePrevDataValues = null;
+        }
+        // MEMORY LEAK FIX: Clear form reference
+        this.form = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LiveFormDirective, deps: [{ token: FormComponent, self: true }, { token: i1.LiveTableComponent, optional: true }, { token: i2.ToDatePipe }, { token: i3.AbstractDialogService }, { token: 'formlayout', attribute: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LiveFormDirective, isStandalone: true, selector: "[wmLiveForm]", host: { listeners: { "keydown": "onKeydownHandler($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LiveFormDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wmLiveForm]'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [FormComponent]
+                }] }, { type: i1.LiveTableComponent, decorators: [{
+                    type: Optional
+                }] }, { type: i2.ToDatePipe }, { type: i3.AbstractDialogService }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['formlayout']
+                }] }], propDecorators: { onKeydownHandler: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-form.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/data/form/src/live-form/live-form.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Inject, Optional, Self, Attribute, HostListener, OnDestroy } from '@angular/core';\n\nimport { $appDigest, AbstractDialogService, DataSource, DataType, debounce, getClonedObject, getFiles, getValidDateObject, isDateTimeType, isDefined, isEmptyObject } from '@wm/core';\nimport { ALLFIELDS, applyFilterOnField, fetchRelatedFieldData, getDistinctValuesForField, isDataSetWidget, Live_Operations, parseValueByType, performDataOperation, ToDatePipe } from '@wm/components/base';\nimport { LiveTableComponent } from '@wm/components/data/live-table';\n\nimport { registerLiveFormProps } from '../form.props';\nimport { FormComponent } from '../form.component';\nimport {forEach, fromPairs, get, isEmpty, isEqual, isString, map, some, split} from \"lodash-es\";\n\nconst isTimeType = field => field.widgettype === DataType.TIME || (field.type === DataType.TIME && !field.widgettype);\nconst getValidTime = val => {\n    if (val) {\n        const date = (new Date()).toDateString();\n        return (new Date(`${date} ${val}`)).getTime();\n    }\n    return undefined;\n};\n\n@Directive({\n  standalone: true,\n    selector: '[wmLiveForm]'\n})\nexport class LiveFormDirective implements OnDestroy {\n    static  initializeProps = registerLiveFormProps();\n    private _triggeredByUser: boolean;\n    private _debouncedSavePrevDataValues = debounce(() => {\n        this.savePrevDataValues();\n    }, 250);\n\n    @HostListener('keydown', ['$event']) onKeydownHandler(event: KeyboardEvent) {\n        this._triggeredByUser = true;\n    }\n\n    constructor(\n        @Self() @Inject(FormComponent) private form,\n        @Optional() liveTable: LiveTableComponent,\n        public datePipe: ToDatePipe,\n        private dialogService: AbstractDialogService,\n        @Attribute('formlayout') formlayout: string\n    ) {\n        // If parent live table is present and this form is first child of live table, set this form instance on livetable\n        if (liveTable) {\n            if (!this.form.parentForm) {\n                this.form._liveTableParent = liveTable;\n            }\n            this.form.isLayoutDialog = liveTable.isLayoutDialog;\n            liveTable.onFormReady(this.form);\n        } else {\n            this.form.isLayoutDialog = formlayout === 'dialog';\n        }\n        // CUD operations\n        form.cancel = this.cancel.bind(this);\n        form.reset = this.reset.bind(this);\n        form.delete = this.delete.bind(this);\n        form.save = this.save.bind(this);\n        form.saveAndNew = this.saveAndNew.bind(this);\n        form.saveAndView = this.saveAndView.bind(this);\n\n        form.setPrimaryKey = this.setPrimaryKey.bind(this);\n        form.constructDataObject = this.constructDataObject.bind(this);\n        form.changeDataObject = this.setFormData.bind(this);\n        form.setFormData = this.setFormData.bind(this);\n        form.findOperationType = this.findOperationType.bind(this);\n        form.clearData = this.clearData.bind(this);\n        form.onFieldDefaultValueChange = this.onFieldDefaultValueChange.bind(this);\n        form.onDataSourceChange = this.onDataSourceChange.bind(this);\n        form.onFieldValueChange = this.onFieldValueChange.bind(this);\n        form.submitForm = this.submitForm.bind(this);\n        form.form_registerFormFields = form.registerFormFields;\n        form.registerFormFields = this.registerFormFields.bind(this);\n    }\n\n    /*\n    WMS:18583\n    Overriding 'registerFormFields' for liveForms,\n    On Each field added, check if the dataSource is updated or not\n    if the field is added after the dataSource is updated at LiveForm, retrigger\n    */\n    registerFormFields(formField) {\n        const formFields = this.form.getFormFields();\n        this.form.form_registerFormFields(formField);\n        if (this.form.isDataSourceUpdated) {\n            this._updateFieldOnDataSourceChange(formField, formFields);\n        }\n    }\n    private _updateFieldOnDataSourceChange(field, formFields) {\n        if (!field.isDataSetBound && isDataSetWidget(field.widgettype)) {\n            if (field['is-related']) {\n                field.isDataSetBound = true;\n                fetchRelatedFieldData(this.form.datasource, field.widget, {\n                    relatedField: field.key,\n                    datafield: ALLFIELDS,\n                    widget: 'widgettype',\n                });\n            } else {\n                getDistinctValuesForField(this.form.datasource, field.widget, {\n                    widget: 'widgettype',\n                    enableemptyfilter: this.form.enableemptyfilter\n                });\n                applyFilterOnField(this.form.datasource, field.widget, formFields, field.value, {isFirst: true});\n            }\n        }\n    }\n    onDataSourceChange() {\n        if (get(this.form.formFields, 'length')) {\n            this.form.isDataSourceUpdated = true;\n        }\n        const formFields = this.form.getFormFields();\n        formFields.forEach(field => {\n            this._updateFieldOnDataSourceChange(field, formFields);\n        });\n    }\n\n    onFieldDefaultValueChange(field, nv) {\n        // In Edit, do  not set default values\n        if (this.form.operationType === 'update') {\n            return;\n        }\n        // Set the default value only if it exists.\n        if (isDefined(nv) && nv !== null && nv !== '' && nv !== 'null') {\n            field.value = parseValueByType(nv, field.type, field.widgettype, field.trailingzero);\n        } else {\n            field.value = undefined;\n        }\n\n        // WMS-22434: For default value set on individual form fields, do not mark the form as dirty.\n        if (this.form.dirty && !this._triggeredByUser) {\n            this.form.markAsPristine();\n        }\n        this._debouncedSavePrevDataValues();\n    }\n\n    onFieldValueChange(field, nv) {\n        applyFilterOnField(this.form.datasource, field.widget, this.form.formFields, nv);\n    }\n\n    getBlobURL(dataObj, key, value) {\n        let href = '';\n        let primaryKeys;\n        let primaryKey;\n        if (value === null || value === undefined || !this.form.datasource) {\n            return href;\n        }\n        primaryKeys = this.form.datasource.execute(DataSource.Operation.GET_PRIMARY_KEY) || [];\n        primaryKey  = dataObj[primaryKeys[0]];\n        href += this.form.datasource.execute(DataSource.Operation.GET_BLOB_URL, {\n            primaryValue: primaryKey,\n            columnName: key\n        });\n        href += '?' + Math.random();\n        return href;\n    }\n\n    setFormData(dataObj, formFields?) {\n        if (!dataObj) {\n            return;\n        }\n        formFields = formFields || this.form.formFields;\n        formFields.forEach(field => {\n            const value = get(dataObj, field.key || field.name);\n            if (isTimeType(field)) {\n                field.value = getValidTime(value);\n            } else if (field.type === DataType.BLOB) {\n                this.form.resetFileUploadWidget(field, true);\n                field.href  = this.getBlobURL(dataObj, field.key, value);\n                field.value = isString(value) ? '' : value;\n            } else {\n                this.form.setFieldValue(field, dataObj);\n            }\n        });\n        this.savePrevDataValues();\n        this.form.constructDataObject();\n    }\n\n    onDataSourceUpdate(response, newForm, updateMode) {\n        if (newForm) {\n            this.form.new();\n        } else {\n            this.form.setFormData(response);\n            this.closeDialog();\n        }\n        this.form.isUpdateMode = isDefined(updateMode) ? updateMode : true;\n    }\n\n    savePrevformFields() {\n        this.form.prevformFields = getClonedObject(this.form.formFields.map(field => {\n            return {\n                'key': field.key,\n                'type': field.type,\n                'widgettype': field.widgettype,\n                'outputformat': field.outputformat,\n                'value': field.value\n            };\n        }));\n    }\n\n    getPrevformFields() {\n        this.form.formFields.map(field => {\n            const prevField = this.form.prevformFields.find(pField => pField.key === field.key);\n            field.value = prevField.value;\n        });\n    }\n\n    getDataObject() {\n        if (this.form.operationType === Live_Operations.INSERT) {\n            return {};\n        }\n        if (isDefined(this.form.prevDataObject) && !isEmptyObject(this.form.prevDataObject)) {\n            return getClonedObject(this.form.prevDataObject);\n        }\n        return getClonedObject(this.form.formdata || {});\n    }\n\n    constructDataObject(isPreviousData?) {\n        const dataObject = this.getDataObject();\n        const formName = this.form.name;\n        let formFields;\n        formFields = isPreviousData ? this.form.prevformFields : this.form.getFormFields();\n        formFields.forEach(field => {\n            let dateTime,\n                fieldValue;\n            const fieldTarget = split(field.key, '.');\n            const fieldName = fieldTarget[0] || field.key;\n\n            /*collect the values from the fields and construct the object*/\n            /*Format the output of date time widgets to the given output format*/\n            if ((field.widgettype && isDateTimeType(field.widgettype)) || isDateTimeType(field.type)) {\n                if (field.value) {\n                    dateTime = getValidDateObject(field.value);\n                    if (field.outputformat === DataType.TIMESTAMP || field.type === DataType.TIMESTAMP) {\n                        fieldValue = field.value ? dateTime : null;\n                    } else if (field.outputformat) {\n                        fieldValue = this.datePipe.transform(dateTime, field.outputformat);\n                    } else {\n                        fieldValue = field.value;\n                    }\n                } else {\n                    fieldValue = undefined;\n                }\n            } else if (field.type === DataType.BLOB) {\n                fieldValue = getFiles(formName, fieldName + '_formWidget', field.multiple);\n            } else if (field.type === DataType.LIST) {\n                fieldValue = field.value || undefined;\n            } else {\n                fieldValue = (field.value === null || field.value === '') ? undefined : field.value;\n            }\n\n            if (fieldTarget.length === 1) {\n                dataObject[fieldName] = fieldValue;\n            } else {\n                dataObject[fieldName] = dataObject[fieldName] || {};\n                dataObject[fieldName][fieldTarget[1]] = fieldValue;\n            }\n        });\n        if (!isPreviousData) {\n            this.form.updateFormDataOutput(dataObject);\n            return this.form.dataoutput;\n        }\n        return dataObject;\n    }\n\n    setPrimaryKey(fieldName) {\n        /*Store the primary key of data*/\n        this.form.primaryKey = this.form.primaryKey || [];\n        if (this.form.primaryKey.indexOf(fieldName) === -1) {\n            this.form.primaryKey.push(fieldName);\n        }\n    }\n\n    findOperationType() {\n        let operation;\n        let isPrimary = false;\n        const sourceOperation = this.form.datasource && this.form.datasource.execute(DataSource.Operation.GET_OPERATION_TYPE);\n        if (sourceOperation && sourceOperation !== 'read') {\n            return sourceOperation;\n        }\n        /*If OperationType is not set then based on the formdata object return the operation type,\n            this case occurs only if the form is outside a livegrid*/\n        /*If the formdata object has primary key value then return update else insert*/\n        if (this.form.primaryKey && !isEmpty(this.form.formdata)) {\n            /*If only one column is primary key*/\n            if (this.form.primaryKey.length === 1) {\n                if (this.form.formdata[this.form.primaryKey[0]]) {\n                    operation = Live_Operations.UPDATE;\n                }\n                /*If only no column is primary key*/\n            } else if (this.form.primaryKey.length === 0) {\n                forEach(this.form.formdata, (value) => {\n                    if (value) {\n                        isPrimary = true;\n                    }\n                });\n                if (isPrimary) {\n                    operation = Live_Operations.UPDATE;\n                }\n                /*If multiple columns are primary key*/\n            } else {\n                isPrimary = some(this.form.primaryKey, (primaryKey) => {\n                    if (this.form.formdata[primaryKey]) {\n                        return true;\n                    }\n                });\n                if (isPrimary) {\n                    operation = Live_Operations.UPDATE;\n                }\n            }\n        }\n        return operation || Live_Operations.INSERT;\n    }\n\n    getPrevDataValues() {\n        const prevDataValues = fromPairs(map(this.form.prevDataValues, (item) => {\n            return [item.key, item.value];\n        })); // Convert of array of values to an object\n        this.form.formFields.forEach(field => {\n            field.value = prevDataValues[field.key] || '';\n            field.resetDisplayInput();\n        });\n        return prevDataValues;\n    }\n\n    savePrevDataValues() {\n        this.form.prevDataValues = this.form.formFields.map((obj) => {\n            return {'key': obj.key, 'value': obj.value};\n        });\n    }\n\n    clearData() {\n        this.form.toggleMessage(false);\n        this.form.emptyDataModel();\n    }\n\n    setReadonlyFields() {\n        this.form.formFields.forEach(field => {\n            field.setReadOnlyState();\n        });\n    }\n\n    reset() {\n        let prevDataValues;\n        this.form.resetFormState();\n        prevDataValues = this.getPrevDataValues();\n        this.form.formFields.forEach(field => {\n            if (field.type === DataType.BLOB || field.widgettype === 'upload') {\n                this.form.resetFileUploadWidget(field, true);\n                field.href = this.getBlobURL(prevDataValues, field.key, field.value);\n            }\n            field.nativeElement.querySelector('input')?.removeAttribute('aria-invalid');\n        });\n        this.form.constructDataObject();\n    }\n\n    closeDialog() {\n        if (this.form.isLayoutDialog) {\n            this.dialogService.close(this.form.dialogId);\n        }\n    }\n\n    cancel() {\n        this.form.clearMessage();\n        this.form.isUpdateMode = false;\n\n        this.form.reset();\n        /*Show the previous selected data*/\n        if (this.form.isSelected) {\n            this.getPrevformFields();\n        }\n        this.form.isUpdateMode = false;\n        if (this.form._liveTableParent) {\n            this.form._liveTableParent.onCancel();\n        } else {\n            /*\n              WMS-18759: dialog close is calling twice and dialog onHidden subscription is calling once from the library\n              due to this if we have another dialog inside liveform and if we click on cancel of second dialog the library\n              subscription is calling for both the dialogs.\n             */\n            this.closeDialog();\n        }\n        $appDigest();\n    }\n\n\n\n    delete(callBackFn) {\n        this.form.resetFormState();\n        this.form.operationType = Live_Operations.DELETE;\n        this.form.prevDataObject = getClonedObject(this.form.formdata || {});\n        this.form.save(undefined, undefined, undefined, callBackFn);\n    }\n\n    // Function use to save the form and open new form after save\n    saveAndNew() {\n        this.save(undefined, true, true);\n    }\n    // Function use to save the form and open new form after save\n    saveAndView() {\n        this.save(undefined, false);\n    }\n\n    submitForm($event) {\n        this.save($event);\n    }\n\n    save(event?, updateMode?, newForm?) {\n        if (!this.form.datasource) {\n            return;\n        }\n        let data, prevData, operationType, isValid;\n        const requestData: any = {};\n\n        operationType = this.form.operationType = this.form.operationType || this.findOperationType();\n\n        // Disable the form submit if form is in invalid state.\n        if (this.form.validateFieldsOnSubmit()) {\n            return;\n        }\n\n        data = getClonedObject(this.form.constructDataObject());\n        prevData = this.form.prevformFields ? this.form.constructDataObject(true) : data;\n\n        try {\n            isValid = this.form.invokeEventCallback('beforeservicecall', {$event: event, $operation: this.form.operationType, $data: data, options: requestData});\n            if (isValid === false) {\n                return;\n            }\n            if (isValid && isValid.error) {\n                this.form.toggleMessage(true, isValid.error, 'error');\n                return;\n            }\n        } catch (err) {\n            if (err.message === 'Abort') {\n                return;\n            }\n        }\n\n        // If operation is update, form is not touched and current data and previous data is same, Show no changes detected message\n        if (this.form.operationType === Live_Operations.UPDATE && this.form.ngform && this.form.ngform.pristine &&\n            (this.form.isSelected && isEqual(data, prevData))) {\n            this.form.toggleMessage(true, this.form.appLocale.MESSAGE_NO_CHANGES, 'info', '');\n            $appDigest();\n            return;\n        }\n\n        requestData.row = data;\n        requestData.transform = true;\n        requestData.skipNotification = true;\n\n        if (operationType === Live_Operations.UPDATE) {\n            requestData.rowData = this.form.formdata;\n            requestData.prevData = prevData;\n        }\n\n        performDataOperation(this.form.datasource, requestData, {\n            operationType: operationType\n        }).then((response) => {\n            const msg = operationType === Live_Operations.INSERT ? this.form.insertmessage : (operationType === Live_Operations.UPDATE ?\n                this.form.updatemessage : this.form.deletemessage);\n            let result;\n\n            if (operationType === Live_Operations.DELETE) {\n                result = requestData.row;\n                this.form.emptyDataModel();\n                this.form.prevDataValues = [];\n                this.form.isSelected = false;\n            } else {\n                result = response;\n            }\n            if (!this.form.onSuccess) {\n                this.form.toggleMessage(true, msg, 'success');\n            }\n            if (this.form._liveTableParent) {\n                // highlight the current updated row\n                this.form._liveTableParent.onResult(operationType, response, newForm, updateMode);\n            } else {\n                /*get updated data without refreshing page*/\n                this.form.datasource.execute(DataSource.Operation.LIST_RECORDS, {\n                    'skipToggleState': true\n                });\n                this.onDataSourceUpdate(response, newForm, updateMode);\n            }\n            return {\n                'result': result,\n                'status': true\n            };\n        }, (error) => {\n            if (!this.form.onError) {\n                this.form.toggleMessage(true, error, 'error');\n            }\n            $appDigest();\n            return {\n                'result': error,\n                'status': false\n            };\n        }).then(response => {\n            // reset the form to pristine state\n            this.form.resetFormState();\n            this.form.onResultCb(response.result, response.status, event);\n        });\n\n\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Cancel debounced function\n        if (this._debouncedSavePrevDataValues && (this._debouncedSavePrevDataValues as any).cancel) {\n            (this._debouncedSavePrevDataValues as any).cancel();\n            this._debouncedSavePrevDataValues = null;\n        }\n\n        // MEMORY LEAK FIX: Clear form reference\n        this.form = null;\n    }\n}\n"]}

package/components/data/form/esm2022/public_api.mjs

@@ -0,0 +1,9 @@
+export { FormComponent } from './form.component';
+export * from './form-widget.directive';
+export * from './form-action/form-action.directive';
+export { FormFieldDirective } from './form-field/form-field.directive';
+export * from './live-actions/live-actions.directive';
+export * from './live-actions/dependson.directive';
+export { LiveFilterDirective } from './live-filter/live-filter.directive';
+export * from './live-form/live-form.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvd2lkZ2V0cy9kYXRhL2Zvcm0vc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUNILGFBQWEsRUFDaEIsTUFBTSxrQkFBa0IsQ0FBQztBQUMxQixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsT0FBTyxFQUNILGtCQUFrQixFQUNyQixNQUFNLG1DQUFtQyxDQUFDO0FBQzNDLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxPQUFPLEVBQ0gsbUJBQW1CLEVBQ3RCLE1BQU0scUNBQXFDLENBQUM7QUFDN0MsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvcm1GaWVsZERpcmVjdGl2ZSB9IGZyb20gJy4vZm9ybS1maWVsZC9mb3JtLWZpZWxkLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBGb3JtQ29tcG9uZW50IH0gZnJvbSAnLi9mb3JtLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBMaXZlRmlsdGVyRGlyZWN0aXZlIH0gZnJvbSAnLi9saXZlLWZpbHRlci9saXZlLWZpbHRlci5kaXJlY3RpdmUnO1xuZXhwb3J0IHtcbiAgICBGb3JtQ29tcG9uZW50XG59IGZyb20gJy4vZm9ybS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLXdpZGdldC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWFjdGlvbi9mb3JtLWFjdGlvbi5kaXJlY3RpdmUnO1xuZXhwb3J0IHtcbiAgICBGb3JtRmllbGREaXJlY3RpdmVcbn0gZnJvbSAnLi9mb3JtLWZpZWxkL2Zvcm0tZmllbGQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGl2ZS1hY3Rpb25zL2xpdmUtYWN0aW9ucy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saXZlLWFjdGlvbnMvZGVwZW5kc29uLmRpcmVjdGl2ZSc7XG5leHBvcnQge1xuICAgIExpdmVGaWx0ZXJEaXJlY3RpdmVcbn0gZnJvbSAnLi9saXZlLWZpbHRlci9saXZlLWZpbHRlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saXZlLWZvcm0vbGl2ZS1mb3JtLmRpcmVjdGl2ZSc7XG4iXX0=