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

package/variables/esm2022/manager/variable/web-socket-variable.manager.mjs

@@ -0,0 +1,289 @@
+import { $WebSocket } from 'angular2-websocket/angular2-websocket';
+import { getValidJSON, isDefined, isInsecureContentRequest, isObject, triggerFn, xmlToJson } from '@wm/core';
+import { BaseVariableManager } from './base-variable.manager';
+import { initiateCallback, metadataService } from '../../util/variable/variables.utils';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { ServiceVariableUtils } from '../../util/variable/service-variable.utils';
+import { forEach, get } from "lodash-es";
+export class WebSocketVariableManager extends BaseVariableManager {
+    constructor() {
+        super(...arguments);
+        this.scope_var_socket_map = new Map();
+        this.PROPERTY = {
+            'SERVICE': 'service',
+            'DATA_UPDATE_STRATEGY': 'dataUpdateStrategy',
+            'DATA_LIMIT': 'dataLimit'
+        };
+        this.DATA_UPDATE_STRATEGY = {
+            'REFRESH': 'refresh',
+            'PREPEND': 'prepend',
+            'APPEND': 'append'
+        };
+    }
+    /**
+     * returns the state of property to decide weather to append new messages to dataSet or not
+     * @param variable
+     * @returns boolean
+     */
+    shouldAppendData(variable) {
+        variable = variable || this;
+        return variable[this.PROPERTY.DATA_UPDATE_STRATEGY] !== this.DATA_UPDATE_STRATEGY.REFRESH;
+    }
+    /**
+     * returns the state of property to decide weather to APPEND or PREPEND new messages to dataSet
+     * @param variable
+     * @returns boolean
+     */
+    shouldAppendLast(variable) {
+        return variable[this.PROPERTY.DATA_UPDATE_STRATEGY] === this.DATA_UPDATE_STRATEGY.APPEND;
+    }
+    /**
+     * returns upper limit on number of records to be in dataSet
+     * this is applicable only when appendData is true
+     * @param variable
+     * @returns {dataLimit}
+     */
+    getDataLimit(variable) {
+        return variable.dataLimit;
+    }
+    /**
+     * get url from wmServiceOperationInfo
+     * @param variable
+     * @returns {*}
+     */
+    getURL(variable) {
+        const prefabName = variable.getPrefabName();
+        const opInfo = prefabName ?
+            get(metadataService.getByOperationId(variable.operationId, prefabName), 'wmServiceOperationInfo') :
+            get(metadataService.getByOperationId(variable.operationId), 'wmServiceOperationInfo');
+        const inputFields = variable.dataBinding;
+        // add sample values to the params (url and path)
+        forEach(opInfo.parameters, function (param) {
+            param.sampleValue = inputFields[param.name];
+        });
+        // although, no header params will be present, keeping 'skipCloakHeaders' flag if support provided later
+        $.extend(opInfo, {
+            skipCloakHeaders: true
+        });
+        // call common method to prepare config for the service operation info.
+        const config = ServiceVariableUtils.constructRequestParams(variable, opInfo, inputFields);
+        /* if error found, return */
+        if (config.error && config.error.message) {
+            this._onSocketError(variable, { data: config.error.message });
+            return;
+        }
+        return config.url;
+    }
+    /**
+     * handler for onMessage event on a socket connection for a variable
+     * the data returned is converted to JSON from string/xml and assigned to dataSet of variable
+     * If not able to do so, message is simply assigned to the dataSet of variable
+     * If appendData property is set, the message is appended to the dataSet, else it replaces the existing value of dataSet
+     * @param variable
+     * @param evt
+     * @private
+     */
+    _onSocketMessage(variable, evt) {
+        let data = get(evt, 'data'), dataLength, dataLimit, shouldAddToLast, insertIdx;
+        data = getValidJSON(data) || xmlToJson(data) || data;
+        // EVENT: ON_MESSAGE
+        const value = initiateCallback(VARIABLE_CONSTANTS.EVENT.MESSAGE_RECEIVE, variable, data, evt);
+        data = isDefined(value) ? value : data;
+        if (this.shouldAppendData(variable)) {
+            variable.dataSet = variable.dataSet || [];
+            dataLength = variable.dataSet.length;
+            dataLimit = this.getDataLimit(variable);
+            shouldAddToLast = this.shouldAppendLast(variable);
+            if (dataLimit && (dataLength >= dataLimit)) {
+                if (shouldAddToLast) {
+                    variable.dataSet.shift();
+                }
+                else {
+                    variable.dataSet.pop();
+                }
+            }
+            insertIdx = shouldAddToLast ? dataLength : 0;
+            variable.dataSet.splice(insertIdx, 0, data);
+        }
+        else {
+            variable.dataSet = isDefined(value) ? value : data;
+        }
+    }
+    /**
+     * calls the ON_BEFORE_SEND callback on the variable
+     * @param variable
+     * @param message
+     * @returns {*}
+     * @private
+     */
+    _onBeforeSend(variable, message) {
+        // EVENT: ON_BEFORE_SEND
+        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_SEND, variable, message);
+    }
+    /**
+     * calls the ON_BEFORE_CLOSE callback assigned to the variable
+     * @param variable
+     * @param evt
+     * @returns {*}
+     * @private
+     */
+    _onBeforeSocketClose(variable, evt) {
+        // EVENT: ON_BEFORE_CLOSE
+        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_CLOSE, variable, get(evt, 'data'), evt);
+    }
+    /**
+     * calls the ON_BEFORE_OPEN callback assigned
+     * called just before the connection is open
+     * @param variable
+     * @param evt
+     * @returns {*}
+     * @private
+     */
+    _onBeforeSocketOpen(variable, evt) {
+        // EVENT: ON_BEFORE_OPEN
+        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_OPEN, variable, get(evt, 'data'), evt);
+    }
+    /**
+     * calls the ON_OPEN event on the variable
+     * this is called once the connection is established by the variable with the target WebSocket service
+     * @param variable
+     * @param evt
+     * @private
+     */
+    _onSocketOpen(variable, evt) {
+        variable._socketConnected = true;
+        // EVENT: ON_OPEN
+        initiateCallback(VARIABLE_CONSTANTS.EVENT.OPEN, variable, get(evt, 'data'), evt);
+        // Send initial request body if it exists and connectOnPageLoad is true
+        if (variable.startUpdate) {
+            const requestBody = get(variable, 'dataBinding.RequestBody');
+            if (requestBody) {
+                setTimeout(() => {
+                    this.send(variable, requestBody);
+                }, 0); // Using setTimeout to ensure connection is fully established
+            }
+        }
+    }
+    freeSocket(variable) {
+        // MEMORY LEAK FIX: Properly clean up socket reference
+        const socket = this.scope_var_socket_map.get(variable);
+        if (socket) {
+            // Clear socket reference from variable
+            variable._socket = null;
+        }
+        this.scope_var_socket_map.delete(variable);
+    }
+    /**
+     * calls the ON_CLOSE event on the variable
+     * this is called on close of an existing connection on a variable
+     * @param variable
+     * @param evt
+     * @private
+     */
+    _onSocketClose(variable, evt) {
+        variable._socketConnected = false;
+        this.freeSocket(variable);
+        // EVENT: ON_CLOSE
+        initiateCallback(VARIABLE_CONSTANTS.EVENT.CLOSE, variable, get(evt, 'data'), evt);
+    }
+    /**
+     * calls the ON_ERROR event on the variable
+     * this is called if an error occurs while connecting to the socket service
+     * @param variable
+     * @param evt
+     * @private
+     */
+    _onSocketError(variable, evt) {
+        variable._socketConnected = false;
+        this.freeSocket(variable);
+        // EVENT: ON_ERROR
+        initiateCallback(VARIABLE_CONSTANTS.EVENT.ERROR, variable, get(evt, 'data') || 'Error while connecting with ' + variable.service, evt);
+    }
+    /**
+     * returns an existing socket connection on the variable
+     * if not present, make the connection and return it
+     * @param variable
+     * @returns {*}
+     */
+    getSocket(variable) {
+        const url = this.getURL(variable);
+        let _socket = this.scope_var_socket_map.get(variable);
+        if (_socket) {
+            return _socket;
+        }
+        if (isInsecureContentRequest(url)) {
+            triggerFn(this._onSocketError.bind(this, variable));
+            return;
+        }
+        _socket = new $WebSocket(url);
+        _socket.onOpen(this._onSocketOpen.bind(this, variable));
+        _socket.onError(this._onSocketError.bind(this, variable));
+        _socket.onMessage(this._onSocketMessage.bind(this, variable));
+        _socket.onClose(this._onSocketClose.bind(this, variable));
+        this.scope_var_socket_map.set(variable, _socket);
+        variable._socket = _socket;
+        return _socket;
+    }
+    /**
+     * opens a socket connection on the variable.
+     * URL & other meta data is fetched from wmServiceOperationInfo
+     * @returns {*}
+     */
+    open(variable, success, error) {
+        const shouldOpen = this._onBeforeSocketOpen(variable);
+        if (shouldOpen === false) {
+            triggerFn(error);
+            return;
+        }
+        const socket = this.getSocket(variable);
+        triggerFn(success);
+        return socket;
+    }
+    /**
+     * closes an existing socket connection on variable
+     */
+    close(variable) {
+        const shouldClose = this._onBeforeSocketClose(variable);
+        const socket = this.getSocket(variable);
+        if (shouldClose === false) {
+            return;
+        }
+        if (socket) {
+            socket.close();
+            // MEMORY LEAK FIX: Clean up socket reference after closing
+            this.freeSocket(variable);
+        }
+    }
+    /**
+     * sends a message to the existing socket connection on the variable
+     * If socket connection not open yet, open a connections and then send
+     * if message provide, it is sent, else the one present in RequestBody param is sent
+     * @param message
+     */
+    send(variable, message) {
+        const socket = this.getSocket(variable);
+        if (!socket) {
+            console.error('WebSocket connection not established');
+            return;
+        }
+        message = message || get(variable, 'dataBinding.RequestBody');
+        if (!message) {
+            console.warn('No message to send');
+            return;
+        }
+        const response = this._onBeforeSend(variable, message);
+        if (response === false) {
+            return;
+        }
+        message = isDefined(response) ? response : message;
+        message = isObject(message) ? JSON.stringify(message) : message;
+        try {
+            socket.send(message, 0);
+        }
+        catch (error) {
+            console.error('Error sending message:', error);
+            this._onSocketError(variable, { data: error.message });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-socket-variable.manager.js","sourceRoot":"","sources":["../../../../../projects/variables/src/manager/variable/web-socket-variable.manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { $WebSocket } from 'angular2-websocket/angular2-websocket';\nimport { getValidJSON, isDefined, isInsecureContentRequest, isObject, triggerFn, xmlToJson } from '@wm/core';\nimport { BaseVariableManager } from './base-variable.manager';\nimport { WebSocketVariable } from '../../model/variable/web-socket-variable';\nimport { initiateCallback, metadataService } from '../../util/variable/variables.utils';\nimport { CONSTANTS, VARIABLE_CONSTANTS } from '../../constants/variables.constants';\nimport { ServiceVariableUtils } from '../../util/variable/service-variable.utils';\nimport { forEach, get } from \"lodash-es\";\n\nexport class WebSocketVariableManager extends BaseVariableManager {\n    scope_var_socket_map = new Map();\n    PROPERTY = {\n        'SERVICE': 'service',\n        'DATA_UPDATE_STRATEGY': 'dataUpdateStrategy',\n        'DATA_LIMIT': 'dataLimit'\n    };\n    DATA_UPDATE_STRATEGY = {\n        'REFRESH': 'refresh',\n        'PREPEND': 'prepend',\n        'APPEND': 'append'\n    };\n\n    /**\n     * returns the state of property to decide weather to append new messages to dataSet or not\n     * @param variable\n     * @returns boolean\n     */\n    private shouldAppendData(variable) {\n        variable = variable || this;\n        return variable[this.PROPERTY.DATA_UPDATE_STRATEGY] !== this.DATA_UPDATE_STRATEGY.REFRESH;\n    }\n\n    /**\n     * returns the state of property to decide weather to APPEND or PREPEND new messages to dataSet\n     * @param variable\n     * @returns boolean\n     */\n    private shouldAppendLast(variable) {\n        return variable[this.PROPERTY.DATA_UPDATE_STRATEGY] === this.DATA_UPDATE_STRATEGY.APPEND;\n    }\n\n    /**\n     * returns upper limit on number of records to be in dataSet\n     * this is applicable only when appendData is true\n     * @param variable\n     * @returns {dataLimit}\n     */\n    private getDataLimit(variable) {\n        return variable.dataLimit;\n    }\n\n    /**\n     * get url from wmServiceOperationInfo\n     * @param variable\n     * @returns {*}\n     */\n    private getURL(variable) {\n        const prefabName = variable.getPrefabName();\n        const opInfo = prefabName ? \n            get(metadataService.getByOperationId(variable.operationId, prefabName), 'wmServiceOperationInfo') : \n            get(metadataService.getByOperationId(variable.operationId), 'wmServiceOperationInfo');\n        const inputFields = variable.dataBinding;\n        \n        // add sample values to the params (url and path)\n        forEach(opInfo.parameters, function (param) {\n            param.sampleValue = inputFields[param.name];\n        });\n        // although, no header params will be present, keeping 'skipCloakHeaders' flag if support provided later\n        $.extend(opInfo, {\n            skipCloakHeaders: true\n        });\n\n        // call common method to prepare config for the service operation info.\n        const config = ServiceVariableUtils.constructRequestParams(variable, opInfo, inputFields);\n        /* if error found, return */\n        if (config.error && config.error.message) {\n            this._onSocketError(variable, {data: config.error.message});\n            return;\n        }\n        return config.url;\n    }\n\n    /**\n     * handler for onMessage event on a socket connection for a variable\n     * the data returned is converted to JSON from string/xml and assigned to dataSet of variable\n     * If not able to do so, message is simply assigned to the dataSet of variable\n     * If appendData property is set, the message is appended to the dataSet, else it replaces the existing value of dataSet\n     * @param variable\n     * @param evt\n     * @private\n     */\n    private _onSocketMessage(variable, evt) {\n        let data = get(evt, 'data'), dataLength, dataLimit, shouldAddToLast, insertIdx;\n        data = getValidJSON(data) || xmlToJson(data) || data;\n        // EVENT: ON_MESSAGE\n        const value = initiateCallback(VARIABLE_CONSTANTS.EVENT.MESSAGE_RECEIVE, variable, data, evt);\n        data = isDefined(value) ? value : data;\n        if (this.shouldAppendData(variable)) {\n            variable.dataSet = variable.dataSet || [];\n            dataLength = variable.dataSet.length;\n            dataLimit = this.getDataLimit(variable);\n            shouldAddToLast = this.shouldAppendLast(variable);\n            if (dataLimit && (dataLength >= dataLimit)) {\n                if (shouldAddToLast) {\n                    variable.dataSet.shift();\n                } else {\n                    variable.dataSet.pop();\n                }\n            }\n            insertIdx = shouldAddToLast ? dataLength : 0;\n            variable.dataSet.splice(insertIdx, 0, data);\n        } else {\n            variable.dataSet = isDefined(value) ? value : data;\n        }\n    }\n\n    /**\n     * calls the ON_BEFORE_SEND callback on the variable\n     * @param variable\n     * @param message\n     * @returns {*}\n     * @private\n     */\n    private _onBeforeSend(variable, message) {\n        // EVENT: ON_BEFORE_SEND\n        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_SEND, variable, message);\n    }\n\n    /**\n     * calls the ON_BEFORE_CLOSE callback assigned to the variable\n     * @param variable\n     * @param evt\n     * @returns {*}\n     * @private\n     */\n    private _onBeforeSocketClose(variable, evt?) {\n        // EVENT: ON_BEFORE_CLOSE\n        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_CLOSE, variable, get(evt, 'data'), evt);\n    }\n\n    /**\n     * calls the ON_BEFORE_OPEN callback assigned\n     * called just before the connection is open\n     * @param variable\n     * @param evt\n     * @returns {*}\n     * @private\n     */\n    private _onBeforeSocketOpen(variable, evt?) {\n        // EVENT: ON_BEFORE_OPEN\n        return initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_OPEN, variable, get(evt, 'data'), evt);\n    }\n\n    /**\n     * calls the ON_OPEN event on the variable\n     * this is called once the connection is established by the variable with the target WebSocket service\n     * @param variable\n     * @param evt\n     * @private\n     */\n    private _onSocketOpen(variable, evt) {\n        variable._socketConnected = true;\n        // EVENT: ON_OPEN\n        initiateCallback(VARIABLE_CONSTANTS.EVENT.OPEN, variable, get(evt, 'data'), evt);\n        \n        // Send initial request body if it exists and connectOnPageLoad is true\n        if (variable.startUpdate) {\n            const requestBody = get(variable, 'dataBinding.RequestBody');\n            if (requestBody) {\n                setTimeout(() => {\n                    this.send(variable, requestBody);\n                }, 0);  // Using setTimeout to ensure connection is fully established\n            }\n        }\n    }\n\n    private freeSocket(variable) {\n        // MEMORY LEAK FIX: Properly clean up socket reference\n        const socket = this.scope_var_socket_map.get(variable);\n        if (socket) {\n            // Clear socket reference from variable\n            variable._socket = null;\n        }\n        this.scope_var_socket_map.delete(variable);\n    }\n\n    /**\n     * calls the ON_CLOSE event on the variable\n     * this is called on close of an existing connection on a variable\n     * @param variable\n     * @param evt\n     * @private\n     */\n    private _onSocketClose(variable, evt) {\n        variable._socketConnected = false;\n        this.freeSocket(variable);\n        // EVENT: ON_CLOSE\n        initiateCallback(VARIABLE_CONSTANTS.EVENT.CLOSE, variable, get(evt, 'data'), evt);\n    }\n\n    /**\n     * calls the ON_ERROR event on the variable\n     * this is called if an error occurs while connecting to the socket service\n     * @param variable\n     * @param evt\n     * @private\n     */\n    private _onSocketError(variable, evt) {\n        variable._socketConnected = false;\n        this.freeSocket(variable);\n        // EVENT: ON_ERROR\n        initiateCallback(VARIABLE_CONSTANTS.EVENT.ERROR, variable, get(evt, 'data') || 'Error while connecting with ' + variable.service, evt);\n    }\n\n    /**\n     * returns an existing socket connection on the variable\n     * if not present, make the connection and return it\n     * @param variable\n     * @returns {*}\n     */\n    private getSocket(variable) {\n        const url = this.getURL(variable);\n        let _socket = this.scope_var_socket_map.get(variable);\n        if (_socket) {\n            return _socket;\n        }\n\n        if (isInsecureContentRequest(url)) {\n            triggerFn(this._onSocketError.bind(this, variable));\n            return;\n        }\n        _socket = new $WebSocket(url);\n        _socket.onOpen(this._onSocketOpen.bind(this, variable));\n        _socket.onError(this._onSocketError.bind(this, variable));\n        _socket.onMessage(this._onSocketMessage.bind(this, variable));\n        _socket.onClose(this._onSocketClose.bind(this, variable));\n\n        this.scope_var_socket_map.set(variable, _socket);\n        variable._socket = _socket;\n        return _socket;\n}\n\n    /**\n     * opens a socket connection on the variable.\n     * URL & other meta data is fetched from wmServiceOperationInfo\n     * @returns {*}\n     */\n    public open(variable: WebSocketVariable, success?, error?) {\n        const shouldOpen = this._onBeforeSocketOpen(variable);\n        if (shouldOpen === false) {\n            triggerFn(error);\n            return;\n        }\n        const socket = this.getSocket(variable);\n        triggerFn(success);\n        return socket;\n    }\n\n    /**\n     * closes an existing socket connection on variable\n     */\n    public close(variable: WebSocketVariable) {\n        const shouldClose = this._onBeforeSocketClose(variable);\n        const socket = this.getSocket(variable);\n        if (shouldClose === false) {\n            return;\n        }\n        if (socket) {\n            socket.close();\n            // MEMORY LEAK FIX: Clean up socket reference after closing\n            this.freeSocket(variable);\n        }\n    }\n\n    /**\n     * sends a message to the existing socket connection on the variable\n     * If socket connection not open yet, open a connections and then send\n     * if message provide, it is sent, else the one present in RequestBody param is sent\n     * @param message\n     */\n    public send(variable: WebSocketVariable, message?: string) {\n        const socket = this.getSocket(variable);\n\n        if (!socket) {\n            console.error('WebSocket connection not established');\n            return;\n        }\n\n        message = message || get(variable, 'dataBinding.RequestBody');\n        if (!message) {\n            console.warn('No message to send');\n            return;\n        }\n\n        const response = this._onBeforeSend(variable, message);\n        if (response === false) {\n            return;\n        }\n        message = isDefined(response) ? response : message;\n        message = isObject(message) ? JSON.stringify(message) : message;\n        \n        try {\n            socket.send(message, 0);\n        } catch (error) {\n            console.error('Error sending message:', error);\n            this._onSocketError(variable, { data: error.message });\n        }\n    }\n}"]}

package/variables/esm2022/model/action/login-action.mjs

@@ -0,0 +1,25 @@
+import { BaseAction } from '@wavemaker-ai/variables';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { VariableManagerFactory } from '../../factory/variable-manager.factory';
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.LOGIN);
+};
+export class LoginAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    login(options, success, error) {
+        return getManager().login(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        return this.login(options, success, error);
+    }
+    cancel() {
+        // TODO[VIBHU]: implement http abort logic
+    }
+    init() {
+        getManager().initBinding(this, 'dataBinding', 'dataBinding');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/variables/esm2022/model/action/logout-action.mjs

@@ -0,0 +1,22 @@
+import { BaseAction } from '@wavemaker-ai/variables';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { VariableManagerFactory } from '../../factory/variable-manager.factory';
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.LOGOUT);
+};
+export class LogoutAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    logout(options, success, error) {
+        getManager().logout(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        this.logout(options, success, error);
+    }
+    cancel() {
+        // TODO[VIBHU]: implement http abort logic
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/variables/esm2022/model/action/navigation-action.mjs

@@ -0,0 +1,26 @@
+import { VariableManagerFactory } from '../../factory/variable-manager.factory';
+import { BaseAction } from '@wavemaker-ai/variables';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.NAVIGATION);
+};
+export class NavigationAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    invoke(options) {
+        getManager().invoke(this, options);
+    }
+    // legacy method.
+    navigate(options) {
+        this.invoke(options);
+    }
+    init() {
+        // static property bindings
+        getManager().initBinding(this, 'dataBinding', 'dataBinding');
+        // dynamic property bindings (e.g. page params)
+        getManager().initBinding(this, 'dataSet', 'dataSet');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/variables/esm2022/model/action/notification-action.mjs

@@ -0,0 +1,91 @@
+import { DataSource, isDefined } from '@wm/core';
+import { VariableManagerFactory } from '../../factory/variable-manager.factory';
+import { BaseAction } from '@wavemaker-ai/variables';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.NOTIFICATION);
+};
+export class NotificationAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    execute(operation, options) {
+        const returnVal = super.execute(operation, options);
+        if (isDefined(returnVal)) {
+            return returnVal;
+        }
+        return new Promise((resolve, reject) => {
+            switch (operation) {
+                case DataSource.Operation.INVOKE:
+                    this.invoke(options, resolve, reject);
+                    break;
+                case DataSource.Operation.NOTIFY:
+                    this.notify(options, resolve, reject);
+                    break;
+                default:
+                    reject(`${operation} operation is not supported on this data source`);
+                    break;
+            }
+        });
+    }
+    // Backward compatible method
+    notify(options, success, error) {
+        getManager().notify(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        this.notify(options, success, error);
+    }
+    getMessage() {
+        return getManager().getMessage(this);
+    }
+    setMessage(text) {
+        return getManager().setMessage(this, text);
+    }
+    clearMessage() {
+        return getManager().setMessage(this, '');
+    }
+    getOkButtonText() {
+        return getManager().getOkButtonText(this);
+    }
+    setOkButtonText(text) {
+        return getManager().setOkButtonText(this, text);
+    }
+    getToasterDuration() {
+        return getManager().getToasterDuration(this);
+    }
+    setToasterDuration(duration) {
+        return getManager().setToasterDuration(this, duration);
+    }
+    getToasterClass() {
+        return getManager().getToasterClass(this);
+    }
+    setToasterClass(classText) {
+        return getManager().setToasterClass(this, classText);
+    }
+    getToasterPosition() {
+        return getManager().getToasterPosition(this);
+    }
+    setToasterPosition(position) {
+        return getManager().setToasterPosition(this, position);
+    }
+    getAlertType() {
+        return getManager().getAlertType(this);
+    }
+    setAlertType(type) {
+        return getManager().setAlertType(this, type);
+    }
+    getCancelButtonText() {
+        return getManager().getCancelButtonText(this);
+    }
+    setCancelButtonText(text) {
+        return getManager().setCancelButtonText(this, text);
+    }
+    init() {
+        // static property bindings
+        getManager().initBinding(this, 'dataBinding', 'dataBinding');
+        // dynamic property bindings
+        getManager().initBinding(this, 'dataSet', 'dataSet');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-action.js","sourceRoot":"","sources":["../../../../../projects/variables/src/model/action/notification-action.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, IDataSource, isDefined } from '@wm/core';\n\nimport { VariableManagerFactory } from '../../factory/variable-manager.factory';\nimport { BaseAction } from '@wavemaker-ai/variables';\nimport { VARIABLE_CONSTANTS } from '../../constants/variables.constants';\n\nconst getManager = () => {\n    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.NOTIFICATION);\n};\n\nexport class NotificationAction extends BaseAction implements IDataSource {\n\n    message: string;\n\n    constructor(variable: any) {\n        super();\n        Object.assign(this as any, variable);\n    }\n\n    execute(operation, options) {\n        const returnVal = super.execute(operation, options);\n        if (isDefined(returnVal)) {\n            return returnVal;\n        }\n\n        return new Promise((resolve, reject) => {\n            switch (operation) {\n                case DataSource.Operation.INVOKE :\n                    this.invoke(options, resolve, reject);\n                    break;\n                case DataSource.Operation.NOTIFY :\n                    this.notify(options, resolve, reject);\n                    break;\n                default :\n                    reject(`${operation} operation is not supported on this data source`);\n                    break;\n            }\n        });\n    }\n\n    // Backward compatible method\n    notify(options, success, error) {\n        getManager().notify(this, options, success, error);\n    }\n\n    invoke(options, success, error) {\n        this.notify(options, success, error);\n    }\n\n    getMessage() {\n        return getManager().getMessage(this);\n    }\n\n    setMessage(text) {\n        return getManager().setMessage(this, text);\n    }\n\n    clearMessage() {\n        return getManager().setMessage(this, '');\n    }\n\n    getOkButtonText() {\n        return getManager().getOkButtonText(this);\n    }\n\n    setOkButtonText(text) {\n        return getManager().setOkButtonText(this, text);\n    }\n\n    getToasterDuration() {\n        return getManager().getToasterDuration(this);\n    }\n\n    setToasterDuration(duration) {\n        return getManager().setToasterDuration(this, duration);\n    }\n\n    getToasterClass() {\n        return getManager().getToasterClass(this);\n    }\n\n    setToasterClass(classText) {\n        return getManager().setToasterClass(this, classText);\n    }\n\n    getToasterPosition() {\n        return getManager().getToasterPosition(this);\n    }\n\n    setToasterPosition(position) {\n        return getManager().setToasterPosition(this, position);\n    }\n\n    getAlertType() {\n        return getManager().getAlertType(this);\n    }\n\n    setAlertType(type) {\n        return getManager().setAlertType(this, type);\n    }\n\n    getCancelButtonText() {\n        return getManager().getCancelButtonText(this);\n    }\n\n    setCancelButtonText(text) {\n        return getManager().setCancelButtonText(this, text);\n    }\n\n    init() {\n        // static property bindings\n        getManager().initBinding(this, 'dataBinding', 'dataBinding');\n\n        // dynamic property bindings\n        getManager().initBinding(this, 'dataSet', 'dataSet');\n    }\n}\n"]}

package/variables/esm2022/model/variable/web-socket-variable.mjs

@@ -0,0 +1,34 @@
+import { ApiAwareVariable } from '@wavemaker-ai/variables';
+import { VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { VariableManagerFactory } from '../../factory/variable-manager.factory';
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.WEBSOCKET);
+};
+export class WebSocketVariable extends ApiAwareVariable {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    open(success, error) {
+        return getManager().open(this, success, error);
+    }
+    close() {
+        return getManager().close(this);
+    }
+    update() {
+        return getManager().update(this);
+    }
+    send(message) {
+        return getManager().send(this, message);
+    }
+    cancel() {
+        return this.close();
+    }
+    invoke(options, success, error) {
+        this.open(success, error);
+    }
+    init() {
+        getManager().initBinding(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/variables/esm2022/public_api.mjs

@@ -0,0 +1,6 @@
+export * from './constants/variables.constants';
+export * from './factory/variable-manager.factory';
+export * from './service/variables.service';
+export * from './service/metadata-service/metadata.service';
+export { appManager, httpService, metadataService, navigationService, routerService, toasterService, oauthService, securityService, dialogService, setDependency, initiateCallback, processBinding, simulateFileDownload, setInput, isFileUploadSupported, getEvaluatedOrderBy, formatExportExpression, debounceVariableCall, formatDate } from './util/variable/variables.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3ZhcmlhYmxlcy9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELE9BQU8sRUFDSCxVQUFVLEVBQ1YsV0FBVyxFQUNYLGVBQWUsRUFDZixpQkFBaUIsRUFDakIsYUFBYSxFQUNiLGNBQWMsRUFDZCxZQUFZLEVBQ1osZUFBZSxFQUNmLGFBQWEsRUFDYixhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2hCLGNBQWMsRUFDZCxvQkFBb0IsRUFDcEIsUUFBUSxFQUNSLHFCQUFxQixFQUNyQixtQkFBbUIsRUFDbkIsc0JBQXNCLEVBQ3RCLG9CQUFvQixFQUNwQixVQUFVLEVBQ2IsTUFBTSxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzL3ZhcmlhYmxlcy5jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9mYWN0b3J5L3ZhcmlhYmxlLW1hbmFnZXIuZmFjdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UvdmFyaWFibGVzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlL21ldGFkYXRhLXNlcnZpY2UvbWV0YWRhdGEuc2VydmljZSc7XG5leHBvcnQge1xuICAgIGFwcE1hbmFnZXIsXG4gICAgaHR0cFNlcnZpY2UsXG4gICAgbWV0YWRhdGFTZXJ2aWNlLFxuICAgIG5hdmlnYXRpb25TZXJ2aWNlLFxuICAgIHJvdXRlclNlcnZpY2UsXG4gICAgdG9hc3RlclNlcnZpY2UsXG4gICAgb2F1dGhTZXJ2aWNlLFxuICAgIHNlY3VyaXR5U2VydmljZSxcbiAgICBkaWFsb2dTZXJ2aWNlLFxuICAgIHNldERlcGVuZGVuY3ksXG4gICAgaW5pdGlhdGVDYWxsYmFjayxcbiAgICBwcm9jZXNzQmluZGluZyxcbiAgICBzaW11bGF0ZUZpbGVEb3dubG9hZCxcbiAgICBzZXRJbnB1dCxcbiAgICBpc0ZpbGVVcGxvYWRTdXBwb3J0ZWQsXG4gICAgZ2V0RXZhbHVhdGVkT3JkZXJCeSxcbiAgICBmb3JtYXRFeHBvcnRFeHByZXNzaW9uLFxuICAgIGRlYm91bmNlVmFyaWFibGVDYWxsLFxuICAgIGZvcm1hdERhdGVcbn0gZnJvbSAnLi91dGlsL3ZhcmlhYmxlL3ZhcmlhYmxlcy51dGlscyc7IFxuIl19