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

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

@@ -0,0 +1,64 @@
+import { PROP_ANY, PROP_BOOLEAN, PROP_NUMBER, PROP_STRING, register } from '@wm/components/base';
+const propsMap = new Map([
+    ['autocomplete', { value: false, ...PROP_BOOLEAN }],
+    ['captionalign', { value: 'left', ...PROP_STRING }],
+    ['captionposition', { value: 'left', ...PROP_STRING }],
+    ['captionsize', PROP_STRING],
+    ['captionwidth', { value: 'xs-12 sm-3 md-3 lg-3', ...PROP_STRING }],
+    ['class', PROP_STRING],
+    ['collapsible', PROP_BOOLEAN],
+    ['dataset', PROP_ANY],
+    ['datasource', PROP_STRING],
+    ['expanded', { value: true, ...PROP_BOOLEAN }],
+    ['formdatasource', PROP_STRING],
+    ['name', PROP_STRING],
+    ['numberOfFields', PROP_NUMBER],
+    ['show', { value: true, ...PROP_BOOLEAN }],
+    ['showindevice', { displayType: 'inline-block', value: 'all', ...PROP_STRING }],
+    ['subheading', PROP_STRING],
+    ['tabindex', { value: 0, ...PROP_NUMBER }],
+    ['title', PROP_STRING],
+    ['itemsperrow', PROP_STRING],
+]);
+export const registerFormProps = () => {
+    const formMap = new Map(propsMap);
+    formMap.set('action', PROP_STRING);
+    formMap.set('defaultmode', { value: 'Edit', ...PROP_STRING });
+    formMap.set('metadata', PROP_STRING);
+    formMap.set('method', PROP_STRING);
+    formMap.set('postmessage', { value: 'Data posted successfully', ...PROP_STRING });
+    formMap.set('target', PROP_STRING);
+    formMap.set('enctype', PROP_STRING);
+    formMap.set('errormessage', { value: 'An error occured. Please try again!', ...PROP_STRING });
+    formMap.set('messagelayout', { value: 'Inline', ...PROP_STRING });
+    formMap.set('formdata', PROP_STRING);
+    formMap.set('novalidate', PROP_BOOLEAN);
+    formMap.set('validationtype', { value: 'default', ...PROP_STRING });
+    formMap.set('iconclass', PROP_STRING);
+    formMap.set('readonly', { value: false, ...PROP_BOOLEAN });
+    register('wm-form', formMap);
+};
+export const registerLiveFormProps = () => {
+    const liveFormMap = new Map(propsMap);
+    liveFormMap.set('defaultmode', { value: 'View', ...PROP_STRING });
+    liveFormMap.set('formlayout', { value: 'inline', ...PROP_STRING });
+    liveFormMap.set('insertmessage', { value: 'Record added successfully', ...PROP_STRING });
+    liveFormMap.set('updatemessage', { value: 'Record updated successfully', ...PROP_STRING });
+    liveFormMap.set('deletemessage', { value: 'Record deleted successfully', ...PROP_STRING });
+    liveFormMap.set('errormessage', { value: 'An error occured. Please try again!', ...PROP_STRING });
+    liveFormMap.set('messagelayout', { value: 'Toaster', ...PROP_STRING });
+    liveFormMap.set('formdata', PROP_STRING);
+    liveFormMap.set('novalidate', PROP_BOOLEAN);
+    liveFormMap.set('validationtype', { value: 'default', ...PROP_STRING });
+    liveFormMap.set('iconclass', PROP_STRING);
+    register('wm-liveform', liveFormMap);
+};
+export const registerLiveFilterProps = () => {
+    const liveFilterMap = new Map(propsMap);
+    liveFilterMap.set('autoupdate', PROP_BOOLEAN);
+    liveFilterMap.set('enableemptyfilter', { value: ' ', ...PROP_STRING });
+    liveFilterMap.set('pagesize', { value: 20, ...PROP_NUMBER });
+    liveFilterMap.set('iconclass', { value: 'wi wi-filter-list', ...PROP_STRING });
+    register('wm-livefilter', liveFilterMap);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.props.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/form/src/form.props.ts"],"names":[],"mappings":"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","sourcesContent":["import {PROP_ANY, PROP_BOOLEAN, PROP_NUMBER, PROP_STRING, register} from '@wm/components/base';\n\nconst propsMap = new Map(\n    [\n        ['autocomplete', {value: false, ...PROP_BOOLEAN}],\n        ['captionalign', {value: 'left', ...PROP_STRING}],\n        ['captionposition', {value: 'left', ...PROP_STRING}],\n        ['captionsize', PROP_STRING],\n        ['captionwidth', {value: 'xs-12 sm-3 md-3 lg-3', ...PROP_STRING}],\n        ['class', PROP_STRING],\n        ['collapsible', PROP_BOOLEAN],\n        ['dataset', PROP_ANY],\n        ['datasource', PROP_STRING],\n        ['expanded', {value: true, ...PROP_BOOLEAN}],\n        ['formdatasource', PROP_STRING],\n        ['name', PROP_STRING],\n        ['numberOfFields', PROP_NUMBER],\n        ['show', {value: true, ...PROP_BOOLEAN}],\n        ['showindevice', {displayType: 'inline-block', value: 'all', ...PROP_STRING}],\n        ['subheading', PROP_STRING],\n        ['tabindex', {value: 0, ...PROP_NUMBER}],\n        ['title', PROP_STRING],\n        ['itemsperrow', PROP_STRING],\n    ]\n);\n\n\nexport const registerFormProps = () => {\n    const formMap = new Map(propsMap);\n    formMap.set('action', PROP_STRING);\n    formMap.set('defaultmode', {value: 'Edit', ...PROP_STRING});\n    formMap.set('metadata', PROP_STRING);\n    formMap.set('method', PROP_STRING);\n    formMap.set('postmessage', {value: 'Data posted successfully', ...PROP_STRING});\n    formMap.set('target', PROP_STRING);\n    formMap.set('enctype', PROP_STRING);\n    formMap.set('errormessage', {value: 'An error occured. Please try again!', ...PROP_STRING});\n    formMap.set('messagelayout', {value: 'Inline', ...PROP_STRING});\n    formMap.set('formdata', PROP_STRING);\n    formMap.set('novalidate', PROP_BOOLEAN);\n    formMap.set('validationtype', {value: 'default', ...PROP_STRING});\n    formMap.set('iconclass', PROP_STRING);\n    formMap.set('readonly',{value: false, ...PROP_BOOLEAN});\n\n    register(\n        'wm-form',\n        formMap\n    );\n};\n\nexport const registerLiveFormProps = () => {\n    const liveFormMap = new Map(propsMap);\n    liveFormMap.set('defaultmode', {value: 'View', ...PROP_STRING});\n    liveFormMap.set('formlayout', {value: 'inline', ...PROP_STRING});\n    liveFormMap.set('insertmessage', {value: 'Record added successfully', ...PROP_STRING});\n    liveFormMap.set('updatemessage', {value: 'Record updated successfully', ...PROP_STRING});\n    liveFormMap.set('deletemessage', {value: 'Record deleted successfully', ...PROP_STRING});\n    liveFormMap.set('errormessage', {value: 'An error occured. Please try again!', ...PROP_STRING});\n    liveFormMap.set('messagelayout', {value: 'Toaster', ...PROP_STRING});\n    liveFormMap.set('formdata', PROP_STRING);\n    liveFormMap.set('novalidate', PROP_BOOLEAN);\n    liveFormMap.set('validationtype', {value: 'default', ...PROP_STRING});\n    liveFormMap.set('iconclass', PROP_STRING);\n\n    register(\n        'wm-liveform',\n        liveFormMap\n    );\n};\n\nexport const registerLiveFilterProps = () => {\n    const liveFilterMap = new Map(propsMap);\n    liveFilterMap.set('autoupdate', PROP_BOOLEAN);\n    liveFilterMap.set('enableemptyfilter', {value: ' ', ...PROP_STRING});\n    liveFilterMap.set('pagesize', {value: 20, ...PROP_NUMBER});\n    liveFilterMap.set('iconclass', {value: 'wi wi-filter-list', ...PROP_STRING});\n\n    register(\n        'wm-livefilter',\n        liveFilterMap\n    );\n};\n"]}

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

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

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

@@ -0,0 +1,151 @@
+import { Directive, Attribute, ContentChildren } from '@angular/core';
+import { AbstractDialogService, App, DataSource } from '@wm/core';
+import { Live_Operations } from '@wm/components/base';
+import { FormComponent } from '../form.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+export class DependsonDirective {
+    constructor(dialogId, dependson, dialogService, app) {
+        this.dialogService = dialogService;
+        this.app = app;
+        // If dialogId is present, form is in dialog mode
+        if (dialogId) {
+            this.isLayoutDialog = true;
+            this.dialogId = dialogId;
+        }
+        this.dependson = dependson;
+        // Listen to the wm-event called from subscribed widgets
+        this.eventSubscription = this.app.subscribe('wm-event', this.handleEvent.bind(this));
+    }
+    openFormDialog() {
+        this.dialogService.open(this.dialogId);
+    }
+    onUpdate(newValue, table, editClicked) {
+        this.editMode = editClicked || this.editMode;
+        this.form.operationType = Live_Operations.UPDATE;
+        this.form.isSelected = true;
+        let rowData = this.currentFormData;
+        if (newValue && table) {
+            if (table.multiselect) {
+                rowData = newValue[0];
+            }
+            else {
+                rowData = newValue[newValue.length - 1];
+            }
+        }
+        this.form.setFormData(rowData);
+        this.form.edit();
+        if (!this.editMode) {
+            this.form.isUpdateMode = false;
+        }
+    }
+    onInsert() {
+        this.form.operationType = Live_Operations.INSERT;
+        this.form.isSelected = true;
+        this.form.setFormData({});
+        this.form.new();
+    }
+    handleEvent(options) {
+        if (this.dependson !== options.widgetName) {
+            return;
+        }
+        this.currentOp = options.eventName;
+        switch (options.eventName) {
+            case Live_Operations.UPDATE:
+                this.currentFormData = options.row;
+                if (this.isLayoutDialog) {
+                    this.openFormDialog();
+                }
+                else {
+                    this.onUpdate(undefined, undefined, true);
+                }
+                break;
+            case Live_Operations.INSERT:
+                if (this.isLayoutDialog) {
+                    this.openFormDialog();
+                }
+                else {
+                    this.onInsert();
+                }
+                break;
+            case Live_Operations.DELETE:
+                this.app.Widgets[this.dependson].call('delete', { row: options.row });
+                break;
+            case Live_Operations.READ:
+                if (!this.isLayoutDialog) {
+                    this.form.isUpdateMode = false;
+                }
+                break;
+            case 'rerender':
+                if (options.dataSource) {
+                    options.dataSource.execute(DataSource.Operation.LIST_RECORDS, {
+                        'skipToggleState': true,
+                        'operation': 'list'
+                    });
+                }
+                break;
+            case 'selectedItemChange':
+                if (options.table) {
+                    this.onUpdate(options.row, options.table);
+                }
+                break;
+            case 'resetEditMode':
+                this.editMode = false;
+        }
+    }
+    onFormRender() {
+        // On opening the form in dialog mode, complete the pending operations
+        if (this.form && this.isLayoutDialog) {
+            this.form.isLayoutDialog = true;
+            setTimeout(() => {
+                if (this.currentOp === Live_Operations.UPDATE) {
+                    this.onUpdate(undefined, undefined, true);
+                }
+                else if (this.currentOp === Live_Operations.INSERT) {
+                    this.onInsert();
+                }
+            }, 250);
+        }
+    }
+    ngAfterContentInit() {
+        // If form instance is present, form is in inline mode. Else, it is in dialog mode and listen to form instance changes
+        if (this.formChildren.first) {
+            this.form = this.formChildren.first;
+        }
+        else {
+            this.formSubscription = this.formChildren.changes.subscribe((val) => {
+                this.form = val.first;
+                this.onFormRender();
+            });
+        }
+        // find the dependent widget (table/list)
+        this.app.notify('setup-cud-listener', this.dependson);
+    }
+    ngOnDestroy() {
+        if (this.formSubscription) {
+            this.formSubscription.unsubscribe();
+        }
+        if (this.eventSubscription) {
+            this.eventSubscription();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DependsonDirective, deps: [{ token: 'dialogid', attribute: true }, { token: 'dependson', attribute: true }, { token: i1.AbstractDialogService }, { token: i1.App }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DependsonDirective, isStandalone: true, selector: "[dependson]", queries: [{ propertyName: "formChildren", predicate: FormComponent, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DependsonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[dependson]'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['dialogid']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['dependson']
+                }] }, { type: i1.AbstractDialogService }, { type: i1.App }], propDecorators: { formChildren: [{
+                type: ContentChildren,
+                args: [FormComponent, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependson.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/data/form/src/live-actions/dependson.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Attribute, ContentChildren, AfterContentInit, OnDestroy } from '@angular/core';\n\nimport { AbstractDialogService, App, DataSource } from '@wm/core';\nimport { Live_Operations } from '@wm/components/base';\nimport { FormComponent } from '../form.component';\n\n@Directive({\n  standalone: true,\n    selector: '[dependson]'\n})\nexport class DependsonDirective implements AfterContentInit, OnDestroy {\n\n    @ContentChildren(FormComponent, {descendants: true}) formChildren;\n\n    private dialogId;\n    private dependson;\n    private isLayoutDialog;\n    private form;\n    private editMode;\n    private currentOp;\n    private currentFormData;\n    private formSubscription;\n    private eventSubscription;\n\n    constructor(\n        @Attribute('dialogid') dialogId: string,\n        @Attribute('dependson') dependson: string,\n        private dialogService: AbstractDialogService,\n        private app: App\n    ) {\n        // If dialogId is present, form is in dialog mode\n        if (dialogId) {\n            this.isLayoutDialog = true;\n            this.dialogId = dialogId;\n        }\n        this.dependson = dependson;\n        // Listen to the wm-event called from subscribed widgets\n        this.eventSubscription = this.app.subscribe('wm-event', this.handleEvent.bind(this));\n    }\n\n    private openFormDialog() {\n        this.dialogService.open(this.dialogId);\n    }\n\n    private onUpdate(newValue?, table?, editClicked?) {\n        this.editMode = editClicked || this.editMode ;\n        this.form.operationType = Live_Operations.UPDATE;\n        this.form.isSelected = true;\n        let rowData = this.currentFormData;\n        if (newValue && table) {\n            if (table.multiselect) {\n                rowData = newValue[0];\n            } else {\n                rowData = newValue[newValue.length - 1];\n            }\n        }\n        this.form.setFormData(rowData);\n        this.form.edit();\n        if (!this.editMode) {\n            this.form.isUpdateMode = false;\n        }\n    }\n    private onInsert() {\n        this.form.operationType = Live_Operations.INSERT;\n        this.form.isSelected = true;\n        this.form.setFormData({});\n        this.form.new();\n    }\n\n    private handleEvent(options) {\n        if (this.dependson !== options.widgetName) {\n            return;\n        }\n        this.currentOp = options.eventName;\n        switch (options.eventName) {\n            case Live_Operations.UPDATE:\n                this.currentFormData = options.row;\n                if (this.isLayoutDialog) {\n                    this.openFormDialog();\n                } else {\n                    this.onUpdate(undefined,undefined, true);\n                }\n                break;\n            case Live_Operations.INSERT:\n                if (this.isLayoutDialog) {\n                    this.openFormDialog();\n                } else {\n                   this.onInsert();\n                }\n                break;\n            case Live_Operations.DELETE:\n                (<any>this.app).Widgets[this.dependson].call('delete', {row: options.row});\n                break;\n            case Live_Operations.READ:\n                if (!this.isLayoutDialog) {\n                    this.form.isUpdateMode = false;\n                }\n                break;\n            case 'rerender':\n                if (options.dataSource) {\n                        options.dataSource.execute(DataSource.Operation.LIST_RECORDS, {\n                            'skipToggleState': true,\n                            'operation': 'list'\n                        });\n                }\n                break;\n            case 'selectedItemChange':\n                if (options.table) {\n                    this.onUpdate(options.row, options.table);\n                }\n                break;\n            case 'resetEditMode':\n                this.editMode = false;\n        }\n    }\n\n    private onFormRender() {\n        // On opening the form in dialog mode, complete the pending operations\n        if (this.form && this.isLayoutDialog) {\n            this.form.isLayoutDialog = true;\n            setTimeout(() => {\n                if (this.currentOp === Live_Operations.UPDATE) {\n                    this.onUpdate(undefined, undefined, true);\n                } else if (this.currentOp === Live_Operations.INSERT) {\n                    this.onInsert();\n                }\n            }, 250);\n        }\n    }\n\n    ngAfterContentInit() {\n        // If form instance is present, form is in inline mode. Else, it is in dialog mode and listen to form instance changes\n        if (this.formChildren.first) {\n            this.form = this.formChildren.first;\n        } else {\n            this.formSubscription = this.formChildren.changes.subscribe((val) => {\n                this.form = val.first;\n                this.onFormRender();\n            });\n        }\n\n        // find the dependent widget (table/list)\n        this.app.notify('setup-cud-listener', this.dependson);\n    }\n\n    ngOnDestroy() {\n        if (this.formSubscription) {\n            this.formSubscription.unsubscribe();\n        }\n        if (this.eventSubscription) {\n            this.eventSubscription();\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,173 @@
+import { Directive, Inject, Self } from '@angular/core';
+import { AbstractDialogService, App, DataSource, triggerFn } from '@wm/core';
+import { Live_Operations, performDataOperation } from '@wm/components/base';
+import { ListComponent } from '@wm/components/data/list';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+export class LiveActionsDirective {
+    constructor(subscribedWidget, app, dialogService) {
+        this.subscribedWidget = subscribedWidget;
+        this.app = app;
+        this.dialogService = dialogService;
+        subscribedWidget.addRow = this.addRow.bind(this);
+        subscribedWidget.updateRow = this.updateRow.bind(this);
+        subscribedWidget.deleteRow = this.deleteRow.bind(this);
+        subscribedWidget.call = this.call.bind(this);
+    }
+    addRow() {
+        this.app.notify('wm-event', { eventName: Live_Operations.INSERT, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem });
+    }
+    updateRow() {
+        this.app.notify('wm-event', { eventName: Live_Operations.UPDATE, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem });
+    }
+    deleteRow() {
+        this.app.notify('wm-event', { eventName: Live_Operations.DELETE, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem });
+    }
+    successHandler(options, response) {
+        triggerFn(options.success, response);
+    }
+    errorHandler(options, error) {
+        this.app.notifyApp(error, 'error', 'ERROR');
+        triggerFn(options.error, error);
+    }
+    getRecords(options, operation) {
+        let index;
+        let dataNavigator;
+        if (this.subscribedWidget.navigation !== 'None' && this.subscribedWidget.dataNavigator) {
+            dataNavigator = this.subscribedWidget.dataNavigator;
+            // If operation is delete, decrease the data size and check if navigation to previous page is required
+            if (operation === Live_Operations.DELETE) {
+                dataNavigator.dataSize -= 1;
+                dataNavigator.calculatePagingValues();
+                index = dataNavigator.pageCount < dataNavigator.dn.currentPage ? 'prev' : undefined;
+            }
+            else {
+                // If operation is insert, go to last page. If update operation, stay on current page
+                index = operation === Live_Operations.INSERT ? 'last' : 'current';
+                if (index === 'last') {
+                    dataNavigator.dataSize += 1;
+                }
+                dataNavigator.calculatePagingValues();
+            }
+            dataNavigator.navigatePage(index, null, true, response => {
+                this.successHandler(options, response);
+            });
+        }
+        else {
+            this.subscribedWidget.datasource.execute(DataSource.Operation.LIST_RECORDS, {
+                'skipToggleState': true
+            }).then(response => {
+                this.successHandler(options, response);
+            }, err => {
+                this.errorHandler(options, err);
+            });
+        }
+    }
+    performCUDOperation(requestData, operation, options) {
+        performDataOperation(this.subscribedWidget.datasource, requestData, {
+            operationType: operation
+        }).then(response => {
+            if (response.error) {
+                this.errorHandler(options, response.error);
+                return;
+            }
+            if (this.subscribedWidget.datasource.category === 'wm.CrudVariable' && operation === 'delete') {
+                this.subscribedWidget.datasource.execute(DataSource.Operation.LIST_RECORDS, {
+                    'skipToggleState': true
+                }).then(response => {
+                    this.successHandler(options, response);
+                }, err => {
+                    this.errorHandler(options, err);
+                });
+            }
+            else {
+                this.getRecords(options, operation);
+            }
+            // show delete success toaster
+            if (operation === 'delete') {
+                this.app.notifyApp(this.app.appLocale.MESSAGE_DELETE_RECORD_SUCCESS, 'success');
+            }
+        }, (error) => {
+            this.errorHandler(options, error);
+        });
+    }
+    insertRecord(requestData, operation, options) {
+        this.performCUDOperation(requestData, operation, options);
+    }
+    updateRecord(requestData, operation, options) {
+        this.performCUDOperation(requestData, operation, options);
+    }
+    deleteRecord(requestData, operation, options) {
+        // Show the delete confirmation dialog. On Ok, delete the record.
+        this.dialogService.showAppConfirmDialog({
+            title: this.app.appLocale.MESSAGE_DELETE_RECORD || 'Delete Record',
+            iconclass: 'wi wi-delete fa-lg',
+            message: this.subscribedWidget.confirmdelete || 'Are you sure you want to delete this?',
+            oktext: this.subscribedWidget.deleteoktext || 'Ok',
+            canceltext: this.subscribedWidget.deletecanceltext || 'Cancel',
+            onOk: () => {
+                this.performCUDOperation(requestData, operation, options);
+                this.dialogService.closeAppConfirmDialog();
+            },
+            onCancel: () => {
+                triggerFn(options.cancelDeleteCallback);
+                this.dialogService.closeAppConfirmDialog();
+            }
+        });
+    }
+    performOperation(operation, options) {
+        const requestData = {
+            row: options.row,
+            prevData: {},
+            rowData: {},
+            transform: true,
+            skipNotification: true
+        };
+        if (operation === Live_Operations.UPDATE) {
+            requestData.rowData = options.rowData;
+            requestData.prevData = options.prevData;
+        }
+        /* decide routine based on CRUD operation to be performed */
+        switch (operation) {
+            case Live_Operations.INSERT:
+                this.insertRecord(requestData, operation, options);
+                break;
+            case Live_Operations.UPDATE:
+                this.updateRecord(requestData, operation, options);
+                break;
+            case Live_Operations.DELETE:
+                this.deleteRecord(requestData, operation, options);
+                break;
+            case Live_Operations.READ:
+                this.getRecords(options, operation);
+                break;
+        }
+    }
+    // API exposed to make CRUD operations
+    call(operation, options, success, error) {
+        options.success = success;
+        options.error = error;
+        this.performOperation(operation, options);
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear references
+        this.subscribedWidget = null;
+        this.app = null;
+        this.dialogService = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LiveActionsDirective, deps: [{ token: ListComponent, self: true }, { token: i1.App }, { token: i1.AbstractDialogService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LiveActionsDirective, isStandalone: true, selector: "[wmLiveActions]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LiveActionsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wmLiveActions]'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [ListComponent]
+                }] }, { type: i1.App }, { type: i1.AbstractDialogService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-actions.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/data/form/src/live-actions/live-actions.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Inject, OnDestroy, Self } from '@angular/core';\n\nimport { AbstractDialogService, App, DataSource, triggerFn } from '@wm/core';\nimport { Live_Operations, performDataOperation } from '@wm/components/base';\nimport { ListComponent } from '@wm/components/data/list';\n\n@Directive({\n  standalone: true,\n    selector: '[wmLiveActions]'\n})\nexport class LiveActionsDirective implements OnDestroy {\n\n    constructor(\n        @Self() @Inject(ListComponent) private subscribedWidget,\n        private app: App,\n        private dialogService: AbstractDialogService\n    ) {\n        subscribedWidget.addRow = this.addRow.bind(this);\n        subscribedWidget.updateRow = this.updateRow.bind(this);\n        subscribedWidget.deleteRow = this.deleteRow.bind(this);\n        subscribedWidget.call = this.call.bind(this);\n    }\n\n    public addRow() {\n        this.app.notify('wm-event', {eventName: Live_Operations.INSERT, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem});\n    }\n\n    public updateRow() {\n        this.app.notify('wm-event', {eventName: Live_Operations.UPDATE, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem});\n    }\n\n    public deleteRow() {\n        this.app.notify('wm-event', {eventName: Live_Operations.DELETE, widgetName: this.subscribedWidget.name, row: this.subscribedWidget.selecteditem});\n    }\n\n    private successHandler(options, response) {\n        triggerFn(options.success, response);\n    }\n\n    private errorHandler(options, error) {\n        this.app.notifyApp(error, 'error', 'ERROR');\n        triggerFn(options.error, error);\n    }\n\n    public getRecords(options, operation) {\n        let index;\n        let dataNavigator;\n\n        if (this.subscribedWidget.navigation !== 'None' && this.subscribedWidget.dataNavigator) {\n            dataNavigator = this.subscribedWidget.dataNavigator;\n\n            // If operation is delete, decrease the data size and check if navigation to previous page is required\n            if (operation === Live_Operations.DELETE) {\n                dataNavigator.dataSize -= 1;\n                dataNavigator.calculatePagingValues();\n                index = dataNavigator.pageCount < dataNavigator.dn.currentPage ? 'prev' : undefined;\n            } else {\n                // If operation is insert, go to last page. If update operation, stay on current page\n                index = operation === Live_Operations.INSERT ? 'last' : 'current';\n                if (index === 'last') {\n                    dataNavigator.dataSize += 1;\n                }\n                dataNavigator.calculatePagingValues();\n            }\n\n            dataNavigator.navigatePage(index, null, true, response => {\n                this.successHandler(options, response);\n            });\n        } else {\n            this.subscribedWidget.datasource.execute(DataSource.Operation.LIST_RECORDS, {\n                'skipToggleState': true\n            }).then(response => {\n                this.successHandler(options, response);\n            }, err => {\n                this.errorHandler(options, err);\n            });\n        }\n    }\n\n    private performCUDOperation(requestData, operation, options) {\n        performDataOperation(this.subscribedWidget.datasource, requestData, {\n            operationType: operation\n        }).then(response => {\n            if (response.error) {\n                this.errorHandler(options, response.error);\n                return;\n            }\n            if (this.subscribedWidget.datasource.category === 'wm.CrudVariable' && operation === 'delete') {\n                this.subscribedWidget.datasource.execute(DataSource.Operation.LIST_RECORDS, {\n                    'skipToggleState': true\n                }).then(response => {\n                    this.successHandler(options, response);\n                }, err => {\n                    this.errorHandler(options, err);\n                });\n            } else {\n                this.getRecords(options, operation);\n            }\n            // show delete success toaster\n            if (operation === 'delete') {\n                this.app.notifyApp(this.app.appLocale.MESSAGE_DELETE_RECORD_SUCCESS, 'success');\n            }\n        }, (error) => {\n            this.errorHandler(options, error);\n        });\n    }\n\n    private insertRecord(requestData, operation, options) {\n        this.performCUDOperation(requestData, operation, options);\n    }\n\n    private updateRecord(requestData, operation, options) {\n        this.performCUDOperation(requestData, operation, options);\n    }\n\n    private deleteRecord(requestData, operation, options) {\n        // Show the delete confirmation dialog. On Ok, delete the record.\n        this.dialogService.showAppConfirmDialog({\n            title:  this.app.appLocale.MESSAGE_DELETE_RECORD || 'Delete Record',\n            iconclass: 'wi wi-delete fa-lg',\n            message: this.subscribedWidget.confirmdelete || 'Are you sure you want to delete this?',\n            oktext: this.subscribedWidget.deleteoktext || 'Ok',\n            canceltext: this.subscribedWidget.deletecanceltext || 'Cancel',\n            onOk: () => {\n                this.performCUDOperation(requestData, operation, options);\n                this.dialogService.closeAppConfirmDialog();\n            },\n            onCancel: () => {\n                triggerFn(options.cancelDeleteCallback);\n                this.dialogService.closeAppConfirmDialog();\n            }\n        });\n    }\n\n    private performOperation(operation, options) {\n        const requestData = {\n            row: options.row,\n            prevData: {},\n            rowData: {},\n            transform: true,\n            skipNotification: true\n        };\n\n        if (operation === Live_Operations.UPDATE) {\n            requestData.rowData = options.rowData;\n            requestData.prevData = options.prevData;\n        }\n\n        /* decide routine based on CRUD operation to be performed */\n        switch (operation) {\n            case Live_Operations.INSERT:\n                this.insertRecord(requestData, operation, options);\n                break;\n            case Live_Operations.UPDATE:\n                this.updateRecord(requestData, operation, options);\n                break;\n            case Live_Operations.DELETE:\n                this.deleteRecord(requestData, operation, options);\n                break;\n            case Live_Operations.READ:\n                this.getRecords(options, operation);\n                break;\n        }\n    }\n\n    // API exposed to make CRUD operations\n    public call(operation, options, success?, error?) {\n        options.success = success;\n        options.error = error;\n\n        this.performOperation(operation, options);\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Clear references\n        this.subscribedWidget = null;\n        this.app = null;\n        this.dialogService = null;\n    }\n}\n"]}