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

package/variables/fesm2022/index.mjs

@@ -0,0 +1,3236 @@
+import { $rootScope as $rootScope$1, BaseAction, ApiAwareVariable, VARIABLE_CONSTANTS as VARIABLE_CONSTANTS$1, TimerAction, CrudVariable, LiveVariable, ServiceVariable, ModelVariable, wmSetDependency, getTarget, getTargetNodeKey as getTargetNodeKey$1, setValueToNode as setValueToNode$1, internalBoundNodeMap as internalBoundNodeMap$1 } from '@wavemaker-ai/variables';
+import * as i1 from '@wm/core';
+import { $parseEvent, triggerFn, findValueOf, stringStartsWith, getClonedObject, $watch, getBlob, DEFAULT_FORMATS, DataType, extractType, getWmProjectProperties, getValidJSON, isDateTimeType, isDefined, replace as replace$1, xmlToJson, isInsecureContentRequest, isObject as isObject$1, DataSource, _WM_APP_PROJECT, $invokeWatchers, processFilterExpBindNode } from '@wm/core';
+import { noop, debounce, isUndefined, isFunction, forEach, isString, split, join, slice, get, pickBy, isEmpty, includes, toUpper, last, replace, keys, filter, set, isObject, isArray, isNumber, map, trim, remove, isDate, toLower, clone, isNil, capitalize, extend, isBoolean, each, startsWith, find, result, concat, isNull, reject } from 'lodash-es';
+import * as momentLib from 'moment';
+import { $WebSocket } from 'angular2-websocket/angular2-websocket';
+import { jmespath } from '@metrichor/jmespath';
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+import * as i3 from '@angular/router';
+import * as i4 from '@wm/oAuth';
+import * as i5 from '@wm/security';
+
+const CONSTANTS = {
+    isStudioMode: false,
+    isRunMode: true,
+    XSRF_COOKIE_NAME: 'wm_xsrf_token',
+    DEFAULT_TIMER_DELAY: 500,
+    WIDGET_DOESNT_EXIST: 'The widget you\'re trying to navigate to doesn\'t exist on this page'
+};
+const VARIABLE_CONSTANTS = {
+    CATEGORY: {
+        MODEL: 'wm.Variable',
+        LIVE: 'wm.LiveVariable',
+        CRUD: 'wm.CrudVariable',
+        SERVICE: 'wm.ServiceVariable',
+        WEBSOCKET: 'wm.WebSocketVariable',
+        NAVIGATION: 'wm.NavigationAction',
+        NOTIFICATION: 'wm.NotificationAction',
+        TIMER: 'wm.TimerAction',
+        LOGIN: 'wm.LoginAction',
+        LOGOUT: 'wm.LogoutAction',
+    },
+    EVENTS: ['onBefore',
+        'onBeforeUpdate',
+        'onResult',
+        'onBeforeOpen',
+        'onOpen',
+        'onBeforeMessageSend',
+        'onMessageReceive',
+        'onProgress',
+        'onError',
+        'onBeforeDatasetReady',
+        'onCanUpdate',
+        'onClick',
+        'onHide',
+        'onOk',
+        'onCancel',
+        'onBeforeClose',
+        'onClose',
+        'onTimerFire',
+        'onSuccess',
+        'onOnline',
+        'onOffline'],
+    EVENT: {
+        'CAN_UPDATE': 'onCanUpdate',
+        'BEFORE': 'onBefore',
+        'BEFORE_UPDATE': 'onBeforeUpdate',
+        'PREPARE_SETDATA': 'onBeforeDatasetReady',
+        'RESULT': 'onResult',
+        'ERROR': 'onError',
+        'ABORT': 'onAbort',
+        'PROGRESS': 'onProgress',
+        'CLICK': 'onClick',
+        'HIDE': 'onHide',
+        'OK': 'onOk',
+        'CANCEL': 'onCancel',
+        'CLOSE': 'onClose',
+        'TIMER_FIRE': 'onTimerFire',
+        'SUCCESS': 'onSuccess',
+        'BEFORE_OPEN': 'onBeforeOpen',
+        'OPEN': 'onOpen',
+        'BEFORE_SEND': 'onBeforeMessageSend',
+        'MESSAGE_RECEIVE': 'onMessageReceive',
+        'BEFORE_CLOSE': 'onBeforeClose'
+    },
+    OWNER: {
+        'APP': 'App',
+        'PAGE': 'Page'
+    },
+    REST_SUPPORTED_SERVICES: ['JavaService', 'SoapService', 'FeedService', 'RestService', 'SecurityServiceType', 'DataService', 'WebSocketService', 'OpenAPIService'],
+    PAGINATION_PARAMS: ['page', 'size', 'sort'],
+    REST_SERVICE: {
+        'BASE_PATH_KEY': 'x-WM-BASE_PATH',
+        'RELATIVE_PATH_KEY': 'x-WM-RELATIVE_PATH',
+        'OAUTH_PROVIDER_KEY': 'x-WM-PROVIDER_ID',
+        'AUTH_HDR_KEY': 'Authorization',
+        'SECURITY_DEFN': {
+            'BASIC': 'basic',
+            'OAUTH2': 'oauth2',
+        },
+        'AUTH_TYPE': {
+            'BASIC': 'BASIC',
+            'OAUTH': 'OAUTH2',
+            'NONE': 'NONE',
+        },
+        'CONTENT_TYPE_KEY': 'x-WM-CONTENT_TYPE',
+        'ACCESSTOKEN_PLACEHOLDER': {
+            'LEFT': '',
+            'RIGHT': '.access_token'
+        },
+        ERR_TYPE: {
+            NO_ACCESSTOKEN: 'missing_accesstoken',
+            NO_CREDENTIALS: 'no_credentials',
+            METADATA_MISSING: 'metadata_missing',
+            CRUD_OPERATION_MISSING: 'crud_operation_missing',
+            USER_UNAUTHORISED: 'user_unauthorised',
+            REQUIRED_FIELD_MISSING: 'required_field_missing',
+        },
+        ERR_MSG: {
+            NO_ACCESSTOKEN: 'Access token missing',
+            NO_CREDENTIALS: 'No credentials present',
+            METADATA_MISSING: 'Metadata missing for "$variable"',
+            USER_UNAUTHORISED: 'Unauthorized User',
+            CRUD_OPERATION_MISSING: 'Operation "$operation" not allowed for "$variable"',
+            REQUIRED_FIELD_MISSING: 'Required field(s) missing: "${0}"'
+        },
+        UNCLOAKED_HEADERS: ['CONTENT-TYPE', 'ACCEPT', 'CONTENT-LENGTH', 'ACCEPT-ENCODING', 'ACCEPT-LANGUAGE'],
+        PREFIX: {
+            AUTH_HDR_VAL: {
+                BASIC: 'Basic',
+                OAUTH: 'Bearer'
+            },
+            CLOAK_HEADER_KEY: 'X-WM-'
+        }
+    },
+    SERVICE_TYPE: {
+        JAVA: 'JavaService',
+        REST: 'RestService',
+        SOAP: 'SoapService',
+        FEED: 'FeedService',
+        DATA: 'DataService',
+        SECURITY: 'SecurityServiceType',
+        WEBSOCKET: 'WebSocketService',
+        OPENAPI: 'OpenAPIService'
+    },
+    CONTROLLER_TYPE: {
+        QUERY: 'QueryExecution',
+        PROCEDURE: 'ProcedureExecution'
+    },
+    HTTP_STATUS_CODE: {
+        CORS_FAILURE: -1,
+        UNAUTHORIZED: 401,
+        FORBIDDEN: 403
+    },
+    EXPORT_TYPES_MAP: {
+        'EXCEL': '.xlsx',
+        'CSV': '.csv'
+    },
+    DEFAULT_VAR: {
+        'NOTIFICATION': 'appNotification'
+    }
+};
+const WS_CONSTANTS = {
+    NON_BODY_HTTP_METHODS: ['GET', 'HEAD'],
+    CONTENT_TYPES: {
+        FORM_URL_ENCODED: 'application/x-www-form-urlencoded',
+        MULTIPART_FORMDATA: 'multipart/form-data',
+        OCTET_STREAM: 'application/octet-stream'
+    }
+};
+const MODE_CONSTANTS = {
+    LIGHT: 'light',
+    DEFAULT: 'default',
+    COLOR: 'color',
+    FONT: 'font',
+    SPACE: 'space',
+    RADIUS: 'radius',
+    MODE_KEY: 'app-mode'
+};
+const DB_CONSTANTS = {
+    'DATABASE_MATCH_MODES': {
+        'like': 'LIKE',
+        'start': 'STARTING_WITH',
+        'startignorecase': 'STARTING_WITH_IGNORECASE',
+        'end': 'ENDING_WITH',
+        'endignorecase': 'ENDING_WITH_IGNORECASE',
+        'anywhere': 'CONTAINING',
+        'anywhereignorecase': 'CONTAINING_IGNORECASE',
+        'nowhere': 'DOES_NOT_CONTAIN',
+        'nowhereignorecase': 'DOES_NOT_CONTAIN_IGNORECASE',
+        'exact': 'EQUALS',
+        'exactignorecase': 'EQUALS_IGNORECASE',
+        'notequals': 'NOT_EQUALS',
+        "notequalsignorecase": "NOT_EQUALS_IGNORECASE",
+        'between': 'BETWEEN',
+        'in': 'IN',
+        "notin": "NOTIN",
+        'lessthan': 'LESS_THAN',
+        'lessthanequal': 'LESS_THAN_OR_EQUALS',
+        'greaterthan': 'GREATER_THAN',
+        'greaterthanequal': 'GREATER_THAN_OR_EQUALS',
+        'null': 'NULL',
+        'isnotnull': 'IS_NOT_NULL',
+        'empty': 'EMPTY',
+        'isnotempty': 'IS_NOT_EMPTY',
+        'nullorempty': 'NULL_OR_EMPTY'
+    },
+    'DATABASE_EMPTY_MATCH_MODES': ['NULL', 'IS_NOT_NULL', 'EMPTY', 'IS_NOT_EMPTY', 'NULL_OR_EMPTY'],
+    'DATABASE_RANGE_MATCH_MODES': ['IN', 'NOTIN', 'BETWEEN', 'LESS_THAN', 'LESS_THAN_OR_EQUALS', 'GREATER_THAN', 'GREATER_THAN_OR_EQUALS', 'NOT_EQUALS'],
+    'DATABASE_NULL_EMPTY_MATCH': {
+        'NULL': 'NULL',
+        'IS_NOT_NULL': 'IS_NOT_NULL',
+        'EMPTY': 'NULL',
+        'IS_NOT_EMPTY': 'IS_NOT_NULL',
+        'NULL_OR_EMPTY': 'NULL'
+    },
+    'DATABASE_MATCH_MODES_WITH_QUERY': {
+        'LIKE': '${0} like ${1}',
+        'STARTING_WITH': '${0} like ${1}',
+        'STARTING_WITH_IGNORECASE': '${0} like ${1}',
+        'ENDING_WITH': '${0} like ${1}',
+        'ENDING_WITH_IGNORECASE': '${0} like ${1}',
+        'CONTAINING': '${0} like ${1}',
+        'CONTAINING_IGNORECASE': '${0} like ${1}',
+        'DOES_NOT_CONTAIN': '${0} not like ${1}',
+        'DOES_NOT_CONTAIN_IGNORECASE': '${0} not like ${1}',
+        'EQUALS': '${0}=${1}',
+        'EQUALS_IGNORECASE': '${0}=${1}',
+        'NOT_EQUALS': '${0}!=${1}',
+        "NOT_EQUALS_IGNORECASE": "${0}!=${1}",
+        'BETWEEN': '${0} between ${1}',
+        'IN': '${0} in ${1}',
+        'NOTIN': "${0} not in ${1}",
+        'LESS_THAN': '${0}<${1}',
+        'LESS_THAN_OR_EQUALS': '${0}<=${1}',
+        'GREATER_THAN': '${0}>${1}',
+        'GREATER_THAN_OR_EQUALS': '${0}>=${1}',
+        'NULL': '${0} is null',
+        'IS_NOT_NULL': '${0} is not null',
+        'EMPTY': '${0}=\'\'',
+        'IS_NOT_EMPTY': '${0}<>\'\'',
+        'NULL_OR_EMPTY': '${0} is null or ${0}=\'\''
+    },
+    'DATABASE_STRING_MODES': ['LIKE', 'STARTING_WITH', 'STARTING_WITH_IGNORECASE', 'ENDING_WITH', 'ENDING_WITH_IGNORECASE', 'CONTAINING', 'CONTAINING_IGNORECASE', 'DOES_NOT_CONTAIN', 'DOES_NOT_CONTAIN_IGNORECASE', 'EQUALS', 'EQUALS_IGNORECASE', 'NOT_EQUALS', "NOT_EQUALS_IGNORECASE"]
+};
+const SWAGGER_CONSTANTS = {
+    WM_DATA_JSON: 'wm_data_json',
+    WM_HTTP_JSON: 'wm_httpRequestDetails'
+};
+const VARIABLE_URLS = {
+    DATABASE: {
+        searchTableData: {
+            url: '/:service/:dataModelName/:entityName/search?page=:page&size=:size&:sort',
+            method: 'POST'
+        },
+        searchTableDataWithQuery: {
+            url: '/:service/:dataModelName/:entityName/filter?page=:page&size=:size&:sort',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        },
+        readTableData: {
+            url: '/:service/:dataModelName/:entityName?page=:page&size=:size&:sort',
+            method: 'GET'
+        },
+        insertTableData: {
+            url: '/:service/:dataModelName/:entityName',
+            method: 'POST'
+        },
+        insertMultiPartTableData: {
+            url: '/:service/:dataModelName/:entityName',
+            method: 'POST',
+            headers: {}
+            // ,transformRequest: WM.identity
+        },
+        updateTableData: {
+            url: '/:service/:dataModelName/:entityName/:id',
+            method: 'PUT'
+        },
+        updateMultiPartTableData: {
+            url: '/:service/:dataModelName/:entityName/:id',
+            method: 'POST',
+            headers: {}
+            // ,transformRequest: WM.identity
+        },
+        deleteTableData: {
+            url: '/:service/:dataModelName/:entityName/:id',
+            method: 'DELETE'
+        },
+        updateCompositeTableData: {
+            url: '/:service/:dataModelName/:entityName/composite-id?:id',
+            method: 'PUT'
+        },
+        periodUpdateCompositeTableData: {
+            url: '/:service/:dataModelName/:entityName/composite-id/periods?:id',
+            method: 'PUT'
+        },
+        updateMultiPartCompositeTableData: {
+            url: '/:service/:dataModelName/:entityName/composite-id?:id',
+            method: 'POST',
+            headers: {}
+            // , transformRequest: WM.identity
+        },
+        deleteCompositeTableData: {
+            url: '/:service/:dataModelName/:entityName/composite-id?:id',
+            method: 'DELETE'
+        },
+        periodDeleteCompositeTableData: {
+            url: '/:service/:dataModelName/:entityName/composite-id/periods?:id',
+            method: 'DELETE'
+        },
+        getDistinctDataByFields: {
+            url: '/:service/:dataModelName/:entityName/aggregations?page=:page&size=:size&:sort',
+            method: 'POST'
+        },
+        exportTableData: {
+            url: '/services/:dataModelName/:entityName/export?:sort',
+            method: 'POST'
+        },
+        readTableRelatedData: {
+            url: '/:service/:dataModelName/:entityName/:id/:relatedFieldName?page=:page&size=:size&:sort',
+            method: 'GET'
+        },
+        executeNamedQuery: {
+            url: '/:service/:dataModelName/queryExecutor/queries/:queryName?page=:page&size=:size&:queryParams',
+            method: 'GET'
+        },
+        executeCustomQuery: {
+            url: '/:service/:dataModelName/queries/execute?page=:page&size=:size',
+            method: 'POST'
+        },
+        executeAggregateQuery: {
+            url: '/services/:dataModelName/:entityName/aggregations?page=:page&size=:size&sort=:sort',
+            method: 'POST'
+        },
+        executeNamedProcedure: {
+            url: '/:service/:dataModelName/procedureExecutor/procedure/execute/:procedureName?page=:page&size=:size&:procedureParams',
+            method: 'GET'
+        },
+        countTableDataWithQuery: {
+            url: '/:service/:dataModelName/:entityName/count?:queryParams',
+            method: 'GET'
+        }
+    },
+    oauthConfiguration: {
+        getAuthorizationUrl: {
+            url: 'services/oauth2/:providerId/authorizationUrl',
+            method: 'GET'
+        }
+    }
+};
+const $rootScope = $rootScope$1;
+
+const moment = momentLib.default || window['moment'];
+const exportTypesMap = { 'EXCEL': '.xlsx', 'CSV': '.csv' };
+let appManager;
+let httpService;
+let metadataService;
+let navigationService;
+let routerService;
+let toasterService;
+let oauthService;
+let securityService;
+let dialogService;
+const DOT_EXPR_REX = /^\[("|')[\w\W]*(\1)\]$/, internalBoundNodeMap = new Map(), timers = new Map();
+const _invoke = (variable, op) => {
+    let debouncedFn, cancelFn = noop, retVal;
+    if (timers.has(variable)) {
+        cancelFn = timers.get(variable).cancel;
+    }
+    cancelFn();
+    debouncedFn = debounce(function () {
+        retVal = variable[op]();
+        // handle promises to avoid uncaught promise errors in console
+        if (retVal instanceof Promise) {
+            retVal.catch(noop);
+        }
+    }, 100);
+    timers.set(variable, debouncedFn);
+    debouncedFn();
+};
+const processVariablePostBindUpdate = (nodeName, nodeVal, nodeType, variable, noUpdate) => {
+    switch (variable.category) {
+        case VARIABLE_CONSTANTS.CATEGORY.LIVE:
+            if (variable.operation === 'read') {
+                if (nodeName === 'dataBinding') {
+                    forEach(nodeVal, function (val, key) {
+                        variable.filterFields[key] = {
+                            'value': val
+                        };
+                    });
+                }
+                else {
+                    variable.filterFields[nodeName] = {
+                        'value': nodeVal,
+                        'type': nodeType
+                    };
+                }
+                /* if auto-update set for the variable with read operation only, get its data */
+                if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.listRecords) && !noUpdate) {
+                    _invoke(variable, 'listRecords');
+                }
+            }
+            else {
+                if (nodeName === 'dataBinding') {
+                    variable.inputFields = nodeVal;
+                }
+                else {
+                    variable.inputFields[nodeName] = nodeVal;
+                }
+                /* if auto-update set for the variable with read operation only, get its data */
+                if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable[variable.operation + 'Record']) && !noUpdate) {
+                    _invoke(variable, variable.operation + 'Record');
+                }
+            }
+            break;
+        case VARIABLE_CONSTANTS.CATEGORY.CRUD:
+            if (variable.operationType === 'list' && variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.invoke) && !noUpdate) {
+                _invoke(variable, 'invoke');
+            }
+            break;
+        case VARIABLE_CONSTANTS.CATEGORY.SERVICE:
+        case VARIABLE_CONSTANTS.CATEGORY.LOGIN:
+            if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.invoke) && !noUpdate) {
+                _invoke(variable, 'invoke');
+            }
+            break;
+    }
+};
+const setDependency = (type, ref) => {
+    switch (type) {
+        case 'appManager':
+            appManager = ref;
+            break;
+        case 'http':
+            httpService = ref;
+            break;
+        case 'metadata':
+            metadataService = ref;
+            break;
+        case 'navigationService':
+            navigationService = ref;
+            break;
+        case 'router':
+            routerService = ref;
+            break;
+        case 'toaster':
+            toasterService = ref;
+            break;
+        case 'oAuth':
+            oauthService = ref;
+            break;
+        case 'security':
+            securityService = ref;
+            break;
+        case 'dialog':
+            dialogService = ref;
+            break;
+    }
+};
+const initiateCallback = (type, variable, data, options, skipDefaultNotification) => {
+    /*checking if event is available and variable has event property and variable event property bound to function*/
+    const eventValues = variable[type], callBackScope = variable._context;
+    let errorVariable;
+    /**
+     * For error event:
+     * trigger app level error handler.
+     * if no event is assigned, trigger default appNotification variable.
+     */
+    if (type === VARIABLE_CONSTANTS.EVENT.ERROR && !skipDefaultNotification) {
+        if (!eventValues) {
+            /* in case of error, if no event assigned, handle through default notification variable */
+            errorVariable = callBackScope.Actions[VARIABLE_CONSTANTS.DEFAULT_VAR.NOTIFICATION];
+            if (errorVariable) {
+                data = errorVariable.getMessage() || data;
+                data = isString(data) ? data : 'An error has occured. Please check the app logs.';
+                errorVariable.invoke({ 'message': data }, undefined, undefined);
+                // $rootScope.$evalAsync(function () {
+                // $rootScope.$emit("invoke-service", VARIABLE_CONSTANTS.DEFAULT_VAR.NOTIFICATION, {scope: callBackScope, message: response});
+                // });
+            }
+        }
+    }
+    // TODO: [Vibhu], check whether to support legacy event calling mechanism (ideally, it should have been migrated)
+    const fn = $parseEvent(variable[type]);
+    if (type === VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE) {
+        if (variable.category === 'wm.LiveVariable' && variable.operation === 'read') {
+            return fn(variable._context, { variable: variable, dataFilter: data, options: options });
+        }
+        else {
+            return fn(variable._context, { variable: variable, inputData: data, options: options });
+        }
+    }
+    else {
+        return fn(variable._context, { variable: variable, data: data, options: options });
+    }
+};
+const triggerOnTimeout = (success) => {
+    setTimeout(() => { triggerFn(success); }, 500);
+};
+const downloadFilefromResponse = (response, headers, success, error) => {
+    // check for a filename
+    let filename = '', filenameRegex, matches, type, blob, URL, downloadUrl, popup;
+    const disposition = headers.get('Content-Disposition');
+    if (disposition && disposition.indexOf('attachment') !== -1) {
+        filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
+        matches = filenameRegex.exec(disposition);
+        if (matches !== null && matches[1]) {
+            filename = matches[1].replace(/['"]/g, '');
+        }
+    }
+    type = headers.get('Content-Type');
+    blob = new Blob([response], { type: type });
+    if (typeof window.navigator.msSaveBlob !== 'undefined') {
+        // IE workaround for "HTML7007: One or more blob URLs were revoked by closing the blob for which they were created. These URLs will no longer resolve as the data backing the URL has been freed."
+        if (window.navigator.msSaveBlob(blob, filename)) {
+            triggerOnTimeout(success);
+        }
+        else {
+            triggerFn(error);
+        }
+    }
+    else {
+        URL = window.URL || window.webkitURL;
+        downloadUrl = URL.createObjectURL(blob);
+        if (filename) {
+            // use HTML5 a[download] attribute to specify filename
+            const a = document.createElement('a');
+            let reader;
+            // safari doesn't support this yet
+            if (typeof a.download === 'undefined') {
+                reader = new FileReader();
+                reader.onloadend = function () {
+                    const url = reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');
+                    popup = window.open(url, '_blank');
+                    if (!popup) {
+                        window.location.href = url;
+                    }
+                };
+                reader.onload = triggerOnTimeout.bind(undefined, success);
+                reader.onerror = error;
+                reader.readAsDataURL(blob);
+            }
+            else {
+                a.href = downloadUrl;
+                a.download = filename;
+                document.body.appendChild(a);
+                a.click();
+                triggerOnTimeout(success);
+            }
+        }
+        else {
+            popup = window.open(downloadUrl, '_blank');
+            if (!popup) {
+                window.location.href = downloadUrl;
+            }
+            triggerOnTimeout(success);
+        }
+        setTimeout(() => { URL.revokeObjectURL(downloadUrl); }, 100); // cleanup
+    }
+};
+const getService = (serviceName) => {
+    if (!serviceName) {
+        return;
+    }
+    return serviceName;
+    // Todo: Shubham, uncomment below code
+    /* /!* get a reference to the element where ng-app is defined *!/
+     let appEl = WM.element('[id=ng-app]'), injector;
+     if (appEl) {
+     try {
+     injector = appEl.injector(); // get the angular injector
+     if (injector) {
+     return injector.get(serviceName); // return the service
+     }
+     } catch (e) {
+     return undefined;
+     }
+     }*/
+};
+/**
+ * Construct the form data params from the URL
+ * @param queryParams
+ * @param params
+ */
+const setParamsFromURL = (queryParams, params) => {
+    queryParams = split(queryParams, '&');
+    forEach(queryParams, function (param) {
+        param = split(param, '=');
+        params[param[0]] = decodeURIComponent(join(slice(param, 1), '='));
+    });
+};
+/**
+ * [Todo: Shubham], Implement Download through I frame
+ * Simulates file download in an app through creating and submitting a hidden form in DOM.
+ * The action will be initiated through a Service Variable
+ *
+ * Query Params
+ * The request params like query params are added as hidden input elements
+ *
+ * Header Params
+ * The header params for a request are also added along with hidden input elements.
+ * This is done as headers can not be set for a form POST call from JavaScript
+ *
+ * Finally, request parameters are sent as follows:
+ * For a GET request, the request data is sent along with the query params.
+ * For POST, it is sent as request body.
+ *
+ * @param variable: the variable that is called from user action
+ * @param requestParams object consisting the info to construct the XHR request for the service
+ */
+const downloadThroughIframe = (requestParams, success, dataBinding, error) => {
+    // Todo: SHubham: URL contains '//' in between which should be handled at the URL formation only
+    if (requestParams.url[1] === '/' && requestParams.url[2] === '/') {
+        requestParams.url = requestParams.url.slice(0, 1) + requestParams.url.slice(2);
+    }
+    let iFrameElement, formEl, paramElement, queryParams = '', data;
+    const IFRAME_NAME = 'fileDownloadIFrame', FORM_NAME = 'fileDownloadForm', CONTENT_TYPE = 'Content-Type', url = requestParams.url, encType = get(requestParams.headers, CONTENT_TYPE), params = pickBy(requestParams.headers, function (val, key) {
+        return key !== CONTENT_TYPE;
+    });
+    /* Todo: shubham : define getService method
+     WS_CONSTANTS    = getService('WS_CONSTANTS');*/
+    /* look for existing iframe. If exists, remove it first */
+    iFrameElement = $('#' + IFRAME_NAME);
+    if (iFrameElement.length) {
+        iFrameElement.first().remove();
+    }
+    iFrameElement = $('<iframe id="' + IFRAME_NAME + '" name="' + IFRAME_NAME + '" class="ng-hide"></iframe>');
+    formEl = $('<form id="' + FORM_NAME + '" name="' + FORM_NAME + '"></form>');
+    /* process query params, append a hidden input element in the form against each param */
+    queryParams += url.indexOf('?') !== -1 ? url.substring(url.indexOf('?') + 1) : '';
+    queryParams += encType === WS_CONSTANTS.CONTENT_TYPES.FORM_URL_ENCODED ? ((queryParams ? '&' : '') + requestParams.dataParams) : '';
+    formEl.attr({
+        'target': iFrameElement.attr('name'),
+        'action': url,
+        'method': requestParams.method,
+        'enctype': !(isEmpty(requestParams.data) && isEmpty(queryParams)) ? encType : WS_CONSTANTS.CONTENT_TYPES.MULTIPART_FORMDATA
+    });
+    // For Non body methods only, set the input fields from query parameters
+    if (includes(WS_CONSTANTS.NON_BODY_HTTP_METHODS, toUpper(requestParams.method))) {
+        setParamsFromURL(queryParams, params); // Set params for URL query params
+    }
+    if (!isEmpty(requestParams.data)) {
+        setParamsFromURL(requestParams.data, params); // Set params for request data
+        data = params;
+    }
+    else {
+        data = isEmpty(dataBinding) ? params : dataBinding;
+    }
+    forEach(data, function (val, key) {
+        paramElement = $('<input type="hidden">');
+        paramElement.attr({
+            'name': key,
+            'value': val
+        });
+        formEl.append(paramElement);
+    });
+    /* append form to iFrame and iFrame to the document and submit the form */
+    $('body').append(iFrameElement);
+    // timeout for IE 10, iframeElement.contents() is empty in IE 10 without timeout
+    setTimeout(function () {
+        let completed = false;
+        iFrameElement.on("load", function () {
+            if (completed)
+                return;
+            const text = iFrameElement.contents().find('body').text();
+            if (text && text.trim()) {
+                completed = true;
+                let message;
+                try {
+                    message = { error: JSON.parse(text.trim()) };
+                }
+                catch (e) {
+                    message = "";
+                }
+                triggerFn(error, message);
+            }
+        });
+        iFrameElement.contents().find('body').append(formEl);
+        formEl.submit();
+        setTimeout(() => {
+            if (!completed) {
+                completed = true;
+                triggerFn(success);
+            }
+        }, 2000);
+    }, 100);
+};
+/**
+ * Makes an XHR call against the config
+ * the response is converted into a blob url, which is assigned to the src attribute of an anchor element with download=true
+ * a click is simulated on the anchor to download the file
+ * @param config
+ * @param success
+ * @param error
+ */
+const downloadThroughAnchor = (config, success, error) => {
+    const url = config.url, method = config.method, data = config.dataParams || config.data, headers = config.headers;
+    headers['Content-Type'] = headers['Content-Type'] || 'application/x-www-form-urlencoded';
+    // Todo: Replace http with getService
+    httpService.send({
+        'target': 'WebService',
+        'action': 'invokeRuntimeRestCall',
+        'method': method,
+        'url': url,
+        'headers': headers,
+        'data': data,
+        'responseType': 'arraybuffer'
+    }).then(function (response) {
+        setTimeout(() => {
+            downloadFilefromResponse(response.body, response.headers, success, error);
+        }, 900);
+    }, function (err) {
+        triggerFn(error, err);
+    });
+};
+/**
+ * appends a timestamp on the passed filename to prevent caching
+ * returns the modified file name
+ * @param fileName
+ * @param exportFormat
+ * @returns {string}
+ */
+const getModifiedFileName = (fileName, exportFormat) => {
+    let fileExtension;
+    const currentTimestamp = Date.now();
+    if (exportFormat) {
+        fileExtension = exportTypesMap[exportFormat];
+    }
+    else {
+        fileExtension = '.' + last(split(fileName, '.'));
+        fileName = replace(fileName, fileExtension, '');
+    }
+    return fileName + '_' + currentTimestamp + fileExtension;
+};
+const getCookieByName = (name) => {
+    // Todo: Shubham Implement cookie native js
+    return 'cookie';
+};
+/**
+ * This function returns the cookieValue if xsrf is enabled.
+ * In device, xsrf cookie is stored in localStorage.
+ * @returns xsrf cookie value
+ */
+const isXsrfEnabled = () => {
+    return false;
+};
+/**
+ * Returns the object node for a bind object, where the value has to be updated
+ * obj.target = "a"
+ * @param obj
+ * @param root
+ * @param variable
+ * @returns {*}
+ */
+const getTargetObj = (obj, root, variable) => {
+    /*
+     * if the target key is in the form as "['my.param']"
+     * keep the target key as "my.param" and do not split further
+     * this is done, so that, the computed value against this binding is assigned as
+     *      {"my.param": "value"}
+     * and not as
+     *      {
+     *          "my": {
+     *              "param": "value"
+     *          }
+     *      }
+     */
+    let target = obj.target, targetObj;
+    const rootNode = variable[root];
+    if (DOT_EXPR_REX.test(target)) {
+        targetObj = rootNode;
+    }
+    else {
+        target = target.substr(0, target.lastIndexOf('.'));
+        if (obj.target === root) {
+            targetObj = variable;
+        }
+        else if (target) {
+            targetObj = findValueOf(rootNode, target, true);
+        }
+        else {
+            targetObj = rootNode;
+        }
+    }
+    return targetObj;
+};
+/**
+ * Gets the key for the target object
+ * the computed value will be updated against this key in the targetObject(computed by getTargetObj())
+ * @param target
+ * @param regex
+ * @returns {*}
+ */
+const getTargetNodeKey = (target) => {
+    /*
+     * if the target key is in the form as "['my.param']"
+     * keep the target key as "my.param" and do not split further
+     * this is done, so that, the computed value against this binding is assigned as
+     *      {"my.param": "value"}
+     * and not as
+     *      {
+     *          "my": {
+     *              "param": "value"
+     *          }
+     *      }
+     */
+    let targetNodeKey;
+    if (DOT_EXPR_REX.test(target)) {
+        targetNodeKey = target.replace(/^(\[["'])|(["']\])$/g, '');
+    }
+    else {
+        targetNodeKey = target.split('.').pop();
+    }
+    return targetNodeKey;
+};
+const setValueToNode = (target, obj, root, variable, value, noUpdate) => {
+    const targetNodeKey = getTargetNodeKey(target), targetObj = getTargetObj(obj, root, variable);
+    value = !isUndefined(value) ? value : obj.value;
+    /* sanity check, user can bind parent nodes to non-object values, so child node bindings may fail */
+    if (targetObj) {
+        targetObj[targetNodeKey] = value;
+    }
+    processVariablePostBindUpdate(targetNodeKey, value, obj.type, variable, noUpdate);
+};
+/**
+ * The model internalBoundNodeMap stores the reference to latest computed values against internal(nested) bound nodes
+ * This is done so that the internal node's computed value is not lost, once its parent node's value is computed at a later point
+ * E.g.
+ * Variable.employeeVar has following bindings
+ * "dataBinding": [
+     {
+         "target": "department.budget",
+         "value": "bind:Variables.budgetVar.dataSet"
+     },
+     {
+         "target": "department",
+         "value": "bind:Variables.departmentVar.dataSet"
+     }
+ ]
+ * When department.budget is computed, employeeVar.dataSet = {
+ *  "department": {
+ *      "budget": {"q1": 1111}
+ *  }
+ * }
+ *
+ * When department is computed
+ *  "department": {
+ *      "name": "HR",
+ *      "location": "Hyderabad"
+ *  }
+ * The budget field (computed earlier) is LOST.
+ *
+ * To avoid this, the latest values against internal nodes (in this case department.budget) are stored in a map
+ * These values are assigned back to internal fields if the parent is computed (in this case department)
+ * @param target
+ * @param root
+ * @param variable
+ */
+const updateInternalNodes = (target, root, variable) => {
+    const boundInternalNodes = keys(get(internalBoundNodeMap.get(variable), [variable.name, root])), targetNodeKey = getTargetNodeKey(target);
+    let internalNodes;
+    function findInternalNodeBound() {
+        return filter(boundInternalNodes, function (node) {
+            // the later condition in check (targetNodeKey === root || targetNodeKey === 'dataBinding') is specifically for live variable of insert/update types
+            return (node !== targetNodeKey && includes(node, targetNodeKey)) || ((targetNodeKey === root || targetNodeKey === 'dataBinding') && node !== targetNodeKey);
+        });
+    }
+    internalNodes = findInternalNodeBound();
+    if ((internalNodes.length)) {
+        forEach(internalNodes, function (node) {
+            setValueToNode(node, { target: node }, root, variable, get(internalBoundNodeMap.get(variable), [variable.name, root, node]));
+        });
+    }
+};
+/**
+ * New Implementation (DataBinding Flat Structure with x-path targets)
+ * processes a dataBinding object, if bound to expression, watches over it, else assigns value to the expression
+ * @param obj dataBinding object
+ * @param scope scope of the variable
+ * @param root root node string (dataBinding for all variables, dataSet for static variable)
+ * @param variable variable object
+ */
+const processBindObject = (obj, scope, root, variable) => {
+    const target = obj.target, targetObj = getTargetObj(obj, root, variable), targetNodeKey = getTargetNodeKey(target), runMode = true;
+    const destroyFn = scope.registerDestroyListener ? scope.registerDestroyListener.bind(scope) : noop;
+    if (stringStartsWith(obj.value, 'bind:')) {
+        const listener = (newVal, oldVal) => {
+            if ((newVal === oldVal && isUndefined(newVal)) || (isUndefined(newVal) && (!isUndefined(oldVal) || !isUndefined(targetObj[targetNodeKey])))) {
+                return;
+            }
+            // Skip cloning for blob column
+            if (!includes(['blob', 'file'], obj.type)) {
+                newVal = getClonedObject(newVal);
+            }
+            setValueToNode(target, obj, root, variable, newVal); // cloning newVal to keep the source clean
+            if (runMode) {
+                /*set the internal bound node map with the latest updated value*/
+                if (!internalBoundNodeMap.has(variable)) {
+                    internalBoundNodeMap.set(variable, {});
+                }
+                set(internalBoundNodeMap.get(variable), [variable.name, root, target], newVal);
+                /*update the internal nodes after internal node map is set*/
+                if (isObject(newVal)) {
+                    updateInternalNodes(target, root, variable);
+                }
+            }
+        };
+        destroyFn($watch(obj.value.replace('bind:', ''), scope, {}, listener, undefined, undefined, undefined, () => variable.isMuted));
+    }
+    else if (!isUndefined(obj.value)) {
+        setValueToNode(target, obj, root, variable, obj.value, true);
+        if (runMode && root !== targetNodeKey) {
+            if (!internalBoundNodeMap.has(variable)) {
+                internalBoundNodeMap.set(variable, {});
+            }
+            set(internalBoundNodeMap.get(variable), [variable.name, root, target], obj.value);
+        }
+    }
+};
+// *********************************************************** PUBLIC *********************************************************** //
+/**
+ * Initializes watchers for binding expressions configured in the variable
+ * @param variable
+ * @param context, scope context in which the variable exists
+ * @param {string} bindSource,  the field in variable where the databindings are configured
+ *                              for most variables, it will be 'dataBinding', hence default fallback is to 'dataBinding'
+ *                              for some it can be 'dataSet' and hence will be passed as param
+ * @param {string} bindTarget, the object field in variable where the computed bindings will be set
+ */
+const processBinding = (variable, context, bindSource, bindTarget) => {
+    bindSource = bindSource || 'dataBinding';
+    bindTarget = bindTarget || 'dataBinding';
+    const bindMap = variable[bindSource];
+    variable[bindSource] = {};
+    variable['_bind' + bindSource] = bindMap;
+    if (!bindMap || !isArray(bindMap)) {
+        return;
+    }
+    bindMap.forEach(function (node) {
+        /* for static variable change the binding with target 'dataBinding' to 'dataSet', as the results have to reflect directly in the dataSet */
+        if (variable.category === 'wm.Variable' && node.target === 'dataBinding') {
+            node.target = 'dataSet';
+        }
+        processBindObject(node, context, bindTarget, variable);
+    });
+};
+/**
+ * Downloads a file in the browser.
+ * Two methods to do so, namely:
+ * 1. downloadThroughAnchor, called if
+ *      - if a header is to be passed
+ *      OR
+ *      - if security is ON and XSRF token is to be sent as well
+ * NOTE: This method does not work with Safari version 10.0 and below
+ *
+ * 2. downloadThroughIframe
+ *      - this method works across browsers and uses an iframe to downlad the file.
+ * @param requestParams request params object
+ * @param fileName represents the file name
+ * @param exportFormat downloaded file format
+ * @param success success callback
+ * @param error error callback
+ */
+const simulateFileDownload = (requestParams, fileName, exportFormat, success, error, dataBinding) => {
+    /*success and error callbacks are executed incase of downloadThroughAnchor
+     Due to technical limitation cannot be executed incase of iframe*/
+    if (!isEmpty(requestParams.headers) || isXsrfEnabled()) {
+        downloadThroughAnchor(requestParams, success, error);
+    }
+    else {
+        downloadThroughIframe(requestParams, success, dataBinding, error);
+    }
+};
+/**
+ * sets the value against passed key on the "inputFields" object in the variable
+ * @param targetObj: the object in which the key, value is to be set
+ * @param variable
+ * @param key: can be:
+ *  - a string e.g. "username"
+ *  - an object, e.g. {"username": "john", "ssn": "11111"}
+ * @param val
+ * - if key is string, the value against it (for that data type)
+ * - if key is object, not required
+ * @param options
+ * @returns {any}
+ */
+const setInput = (targetObj, key, val, options) => {
+    targetObj = targetObj || {};
+    let keys, lastKey, paramObj = {};
+    // content type check
+    if (isObject(options)) {
+        // @ts-ignore
+        switch (options.type) {
+            case 'file':
+                // @ts-ignore
+                val = getBlob(val, options.contentType);
+                break;
+            case 'number':
+                val = isNumber(val) ? val : parseInt(val, 10);
+                break;
+        }
+    }
+    if (isObject(key)) {
+        // check if the passed parameter is an object itself
+        paramObj = key;
+    }
+    else if (key.indexOf('.') > -1) {
+        // check for '.' in key e.g. 'employee.department'
+        keys = key.split('.');
+        lastKey = keys.pop();
+        // Finding the object based on the key
+        targetObj = findValueOf(targetObj, keys.join('.'), true);
+        key = lastKey;
+        paramObj[key] = val;
+    }
+    else {
+        paramObj[key] = val;
+    }
+    forEach(paramObj, function (paramVal, paramKey) {
+        targetObj[paramKey] = paramVal;
+    });
+    return targetObj;
+};
+/**
+ * returns true if HTML5 File API is available else false
+ * @returns {{prototype: Blob; new(blobParts?: any[], options?: BlobPropertyBag): Blob}}
+ */
+const isFileUploadSupported = () => {
+    return (window.File && window.FileReader && window.FileList && window.Blob);
+};
+/**
+ *
+ * @param varOrder
+ * @param optionsOrder
+ * @returns {any}
+ */
+const getEvaluatedOrderBy = (varOrder, optionsOrder) => {
+    let optionFields, varOrderBy;
+    // If options order by is not defined, return variable order
+    if (!optionsOrder || isEmpty(optionsOrder)) {
+        return varOrder;
+    }
+    // If variable order by is not defined, return options order
+    if (!varOrder) {
+        return optionsOrder;
+    }
+    // If both are present, combine the options order and variable order, with options order as precedence
+    varOrder = split(varOrder, ',');
+    optionsOrder = split(optionsOrder, ',');
+    optionFields = map(optionsOrder, function (order) {
+        return split(trim(order), ' ')[0];
+    });
+    // If a field is present in both options and variable, remove the variable orderby
+    remove(varOrder, function (orderBy) {
+        return includes(optionFields, split(trim(orderBy), ' ')[0]);
+    });
+    varOrderBy = varOrder.length ? ',' + join(varOrder, ',') : '';
+    return join(optionsOrder, ',') + varOrderBy;
+};
+/**
+ * formatting the expression as required by backend which was enclosed by ${<expression>}.
+ * @param fieldDefs
+ * returns fieldDefs
+ */
+const formatExportExpression = fieldDefs => {
+    forEach(fieldDefs, function (fieldDef) {
+        if (fieldDef.expression) {
+            fieldDef.expression = '${' + fieldDef.expression + '}';
+        }
+    });
+    return fieldDefs;
+};
+const debounceVariableCall = _invoke;
+const getDateTimeFormatForType = (type) => {
+    return DEFAULT_FORMATS[toUpper(type)];
+};
+// Format value for datetime types
+const _formatDate = (dateValue, type) => {
+    let epoch;
+    if (isDate(dateValue)) {
+        epoch = dateValue.getTime();
+    }
+    else {
+        if (!isNaN(dateValue)) {
+            dateValue = parseInt(dateValue, 10);
+        }
+        epoch = dateValue && moment(dateValue).valueOf();
+    }
+    if (isNaN(epoch) && type !== DataType.TIME) {
+        return epoch;
+    }
+    if (type === DataType.TIMESTAMP) {
+        return epoch;
+    }
+    if (type === DataType.TIME && !epoch) {
+        epoch = moment(new Date().toDateString() + ' ' + dateValue).valueOf();
+    }
+    return dateValue && appManager.getPipe('date').transform(epoch, getDateTimeFormatForType(type));
+};
+// Function to convert values of date time types into default formats
+const formatDate = (value, type) => {
+    if (includes(type, '.')) {
+        type = toLower(extractType(type));
+    }
+    if (isArray(value)) {
+        return map(value, function (val) {
+            return _formatDate(val, type);
+        });
+    }
+    return _formatDate(value, type);
+};
+/**
+ * This method decodes the variable data which is encoded from backend before showing in the widgets.
+ * It takes variable response content as input and iterates recursively,
+ * if the value is string type then it will decode the data.
+ * @param responseContent (Array of objects)
+ */
+const decodeData = (responseContent) => {
+    if (!responseContent) {
+        return responseContent;
+    }
+    if (isArray(responseContent)) {
+        forEach(responseContent, data => {
+            if (isString(data)) {
+                data = htmlDecode(data);
+            }
+            else if (isObject(data)) {
+                forEach(data, (value, key) => {
+                    if (value && isString(value)) {
+                        data[key] = htmlDecode(value);
+                    }
+                    else if (isObject(value)) {
+                        decodeData(value);
+                    }
+                });
+            }
+        });
+    }
+    else if (isObject(responseContent)) {
+        forEach(responseContent, (value, key) => {
+            if (value && isString(value)) {
+                responseContent[key] = htmlDecode(value);
+            }
+            else if (isObject(value)) {
+                decodeData(value);
+            }
+        });
+    }
+    else if (isString(responseContent)) {
+        responseContent = htmlDecode(responseContent);
+        return responseContent;
+    }
+};
+function htmlDecode(input) {
+    return he.unescape(input);
+}
+
+/**
+ * Handles variable navigation operations
+ * @param variable
+ * @param options
+ */
+const navigate = (variable, options) => {
+    variable.dataSet = (options && options.data) || variable.dataSet;
+    let viewName;
+    const pageName = variable.dataBinding.pageName || variable.pageName, operation = variable.operation, urlParams = clone(variable.dataSet), cacheable = isNil(options?.cacheable) ? variable.cacheable : options.cacheable;
+    options = options || {};
+    if (!isNil(cacheable) && (!isString(cacheable) || cacheable.trim() !== '')) {
+        urlParams['_cache_page'] = cacheable;
+    }
+    /* if operation is goToPage, navigate to the pageName */
+    switch (operation) {
+        case 'goToPreviousPage':
+            navigationService.goToPrevious();
+            break;
+        case 'gotoPage':
+            navigationService.goToPage(pageName, {
+                transition: variable.pageTransitions,
+                $event: options.$event,
+                urlParams: urlParams,
+                cacheable: variable.cacheable
+            });
+            break;
+        case 'gotoView':
+            viewName = (variable.dataBinding && variable.dataBinding.viewName) || variable.viewName;
+            break;
+        case 'gotoTab':
+            viewName = (variable.dataBinding && variable.dataBinding.tabName) || variable.tabName;
+            break;
+        case 'gotoAccordion':
+            viewName = (variable.dataBinding && variable.dataBinding.accordionName) || variable.accordionName;
+            break;
+        case 'gotoSegment':
+            viewName = (variable.dataBinding && variable.dataBinding.segmentName) || variable.segmentName;
+            break;
+    }
+    /* if view name found, call routine to navigate to it */
+    if (viewName) {
+        navigationService.goToView(viewName, {
+            pageName: pageName,
+            transition: variable.pageTransitions,
+            $event: options.$event,
+            urlParams: urlParams
+        }, variable);
+    }
+};
+
+class BaseActionManager {
+    initBinding(variable, bindSource, bindTarget) {
+        processBinding(variable, variable._context, bindSource, bindTarget);
+    }
+    notifyInflight(variable, status, data) {
+        appManager.notify('toggle-variable-state', {
+            variable: variable,
+            active: status,
+            data: data
+        });
+    }
+}
+
+class NavigationActionManager extends BaseActionManager {
+    invoke(variable, options) {
+        navigate(variable, options);
+    }
+}
+
+class NotificationActionManager extends BaseActionManager {
+    onToasterClick(variable) {
+        initiateCallback('onClick', variable, '');
+    }
+    onToasterHide(variable) {
+        initiateCallback('onHide', variable, '');
+    }
+    notifyViaToaster(variable, options) {
+        const type = (options.class || variable.dataBinding.class || 'info').toLowerCase(), body = options.message || variable.dataBinding.text, title = options.title, positionClass = 'toast-' + (options.position || variable.dataBinding.toasterPosition || 'bottom right').replace(' ', '-'), partialPage = variable.dataBinding.page, DEFAULT_DURATION = 3000;
+        let duration = parseInt(options.duration || variable.dataBinding.duration, null), toaster;
+        // duration
+        if (!duration) {
+            duration = (duration !== 0 && type === 'success') ? DEFAULT_DURATION : 0;
+        }
+        if (variable.dataBinding.content && variable.dataBinding.content === 'page' && partialPage) {
+            toaster = toasterService.showCustom(partialPage, { positionClass: positionClass, timeOut: duration,
+                partialParams: variable._binddataSet, context: variable._context });
+        }
+        else {
+            toaster = toasterService.show(type, title, body || null, { positionClass: positionClass, timeOut: duration, enableHtml: true });
+        }
+        // callbacks
+        // MEMORY LEAK FIX: Store subscriptions for cleanup (though toaster is short-lived, we track for safety)
+        if (variable.onClick) {
+            const onClickSubscription = toaster.onTap.subscribe(this.onToasterClick.bind(this, variable));
+            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)
+            if (toaster && !toaster._subscriptions) {
+                toaster._subscriptions = [];
+            }
+            if (toaster && toaster._subscriptions) {
+                toaster._subscriptions.push(onClickSubscription);
+            }
+        }
+        if (variable.onHide) {
+            const onHideSubscription = toaster.onHidden.subscribe(this.onToasterHide.bind(this, variable));
+            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)
+            if (toaster && !toaster._subscriptions) {
+                toaster._subscriptions = [];
+            }
+            if (toaster && toaster._subscriptions) {
+                toaster._subscriptions.push(onHideSubscription);
+            }
+        }
+    }
+    getDialogConfig(variable, options, dialogId, closeCallBackFn) {
+        return {
+            'title': options.title || variable.dataBinding.title,
+            'text': options.message || variable.dataBinding.text,
+            'okButtonText': options.okButtonText || variable.dataBinding.okButtonText || 'OK',
+            'cancelButtonText': options.cancelButtonText || variable.dataBinding.cancelButtonText || 'CANCEL',
+            'alerttype': options.alerttype || variable.dataBinding.alerttype || 'information',
+            onOk: () => {
+                // Close the action dialog after triggering onOk callback event
+                dialogService.close(dialogId, undefined, closeCallBackFn);
+            },
+            onCancel: () => {
+                initiateCallback('onCancel', variable, options.data);
+                // Close the action dialog after triggering onCancel callback event
+                dialogService.close(dialogId, undefined);
+            },
+            onClose: () => {
+                initiateCallback('onClose', variable, options.data);
+            }
+        };
+    }
+    notifyViaDialog(variable, options) {
+        const isPrefabType = getWmProjectProperties().type === 'PREFAB';
+        const dialogPrefix = isPrefabType ? 'Prefab' : 'Common';
+        const dialogId = dialogPrefix + capitalize(variable.operation) + 'Dialog';
+        const closeCallBackFn = () => initiateCallback('onOk', variable, options.data);
+        let dialogConfig = this.getDialogConfig(variable, options, dialogId, closeCallBackFn);
+        dialogConfig = isPrefabType ? dialogConfig : { notification: dialogConfig };
+        dialogService.open(dialogId, undefined, dialogConfig);
+    }
+    // *********************************************************** PUBLIC ***********************************************************//
+    notify(variable, options, success, error) {
+        const operation = variable.operation;
+        options = options || {};
+        if (operation === 'toast') {
+            this.notifyViaToaster(variable, options);
+        }
+        else {
+            this.notifyViaDialog(variable, options);
+        }
+    }
+    getMessage(variable) {
+        return variable.dataBinding.text;
+    }
+    setMessage(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.text = text;
+        }
+        return variable.dataBinding.text;
+    }
+    getOkButtonText(variable) {
+        return variable.dataBinding.okButtonText;
+    }
+    setOkButtonText(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.okButtonText = text;
+        }
+        return variable.dataBinding.okButtonText;
+    }
+    getToasterDuration(variable) {
+        return variable.dataBinding.duration;
+    }
+    setToasterDuration(variable, duration) {
+        variable.dataBinding.duration = duration;
+        return variable.dataBinding.duration;
+    }
+    getToasterClass(variable) {
+        return variable.dataBinding.class;
+    }
+    setToasterClass(variable, type) {
+        if (isString(type)) {
+            variable.dataBinding.class = type;
+        }
+        return variable.dataBinding.class;
+    }
+    getToasterPosition(variable) {
+        return variable.dataBinding.class;
+    }
+    setToasterPosition(variable, position) {
+        if (isString(position)) {
+            variable.dataBinding.position = position;
+        }
+        return variable.dataBinding.position;
+    }
+    getAlertType(variable) {
+        return variable.dataBinding.alerttype;
+    }
+    setAlertType(variable, alerttype) {
+        if (isString(alerttype)) {
+            variable.dataBinding.alerttype = alerttype;
+        }
+        return variable.dataBinding.alerttype;
+    }
+    getCancelButtonText(variable) {
+        return variable.dataBinding.cancelButtonText;
+    }
+    setCancelButtonText(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.cancelButtonText = text;
+        }
+        return variable.dataBinding.cancelButtonText;
+    }
+}
+
+class BaseVariableManager {
+    initBinding(variable, bindSource, bindTarget) {
+        processBinding(variable, variable._context, bindSource, bindTarget);
+    }
+    notifyInflight(variable, status, data, options) {
+        appManager.notify('toggle-variable-state', {
+            variable: variable,
+            active: status,
+            data: data,
+            options: options
+        });
+    }
+    /**
+     * This method sets the variable parameter requestTrackId to X-WM-Request-Track-Id which is received in the response headers.
+     * @param response
+     */
+    setRequestTrackId(response, variable) {
+        const requestTrackId = response?.headers?.get('x-wm-request-track-id');
+        if (requestTrackId) {
+            variable._requestTrackId = requestTrackId;
+        }
+    }
+    /**
+     * This method makes the final angular http call that returns an observable.
+     * We attach this observable to variable to cancel a network call
+     * @param requestParams
+     * @param variable
+     * @param dbOperation
+     */
+    httpCall(requestParams, variable, params) {
+        return new Promise((resolve, reject) => {
+            variable._observable = httpService.sendCallAsObservable(requestParams, params).subscribe((response) => {
+                if (response && response.type) {
+                    this.setRequestTrackId(response, variable);
+                    resolve(response);
+                }
+            }, (err) => {
+                this.setRequestTrackId(err, variable);
+                if (httpService.isPlatformSessionTimeout(err)) {
+                    // send the notification manually to hide any context spinners on page.
+                    // [TODO]: any spinners on widget listening on this variable will also go off. Need to see an approach to sovle that.
+                    this.notifyInflight(variable, false, err);
+                    // MEMORY LEAK FIX: Store subscription for cleanup (though it's a one-time promise resolver)
+                    const error401Subscription = err._401Subscriber.asObservable().subscribe(response => {
+                        resolve(response);
+                        // Unsubscribe after resolution
+                        if (error401Subscription && !error401Subscription.closed) {
+                            error401Subscription.unsubscribe();
+                        }
+                    }, e => {
+                        reject(e);
+                        // Unsubscribe after rejection
+                        if (error401Subscription && !error401Subscription.closed) {
+                            error401Subscription.unsubscribe();
+                        }
+                    });
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * This method prepares the options parameter for variable callbacks.
+     * @param xhrObj, The xhrObj to be passed
+     * @param moreOptions, any other info to be passed in the options param
+     */
+    prepareCallbackOptions(xhrObj, moreOptions) {
+        let options = {};
+        options['xhrObj'] = xhrObj;
+        if (moreOptions) {
+            extend(options, moreOptions);
+        }
+        return options;
+    }
+}
+
+class LoginActionManager extends BaseActionManager {
+    validate(params) {
+        let err, paramKey, remembermeKey;
+        const LOGIN_PARAM_REMEMBER_ME = 'j_rememberme';
+        const LOGIN_PARAM_REMEMBER_ME_OLD = ['rememberme', 'remembermecheck'];
+        // for older projects
+        LOGIN_PARAM_REMEMBER_ME_OLD.forEach((old_key) => {
+            if (isBoolean(params[old_key])) {
+                remembermeKey = old_key;
+            }
+        });
+        remembermeKey = remembermeKey || LOGIN_PARAM_REMEMBER_ME;
+        // check remember me
+        params[remembermeKey] = isBoolean(params[remembermeKey]) ? params[remembermeKey] : false;
+        for (paramKey in params) {
+            if (params.hasOwnProperty(paramKey) &&
+                (params[paramKey] === '' || params[paramKey] === undefined)) {
+                err = 'Please provide required credentials';
+                break;
+            }
+        }
+        return err;
+    }
+    migrateOldParams(params) {
+        const loginParams = {}, paramMigrationMap = {
+            'usernametext': 'j_username',
+            'username': 'j_username',
+            'passwordtext': 'j_password',
+            'password': 'j_password',
+            'remembermecheck': 'j_rememberme',
+            'rememberme': 'j_rememberme'
+        };
+        each(params, function (value, key) {
+            if (paramMigrationMap[key]) {
+                loginParams[paramMigrationMap[key]] = value;
+            }
+            else {
+                loginParams[key] = value;
+            }
+        });
+        return loginParams;
+    }
+    /*
+         * This method is used to redirect the user to app base path
+         * After successful navigation to the base path, will reload the app
+    */
+    redirectToAppBasePath() {
+        routerService.navigate(['/']).then(nav => {
+            if (nav) {
+                window.location.reload();
+            }
+        });
+    }
+    login(variable, options, success, error) {
+        let newDataSet;
+        options = options || {};
+        // If login info provided along explicitly with options, don't look into the variable bindings for the same
+        const loginInfo = options.loginInfo || options.input || variable.dataBinding;
+        // client side validation
+        const errMsg = this.validate(loginInfo);
+        /* if error message initialized, return error */
+        if (errMsg) {
+            triggerFn(error, errMsg);
+            initiateCallback('onError', variable, errMsg);
+            return;
+        }
+        // Triggering 'onBeforeUpdate' and considering
+        let params = getClonedObject(loginInfo);
+        const output = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, params);
+        if (isObject(output)) {
+            params = output;
+        }
+        else if (output === false) {
+            triggerFn(error);
+            return;
+        }
+        // migrate old params to new
+        params = this.migrateOldParams(params);
+        // get previously loggedInUser name (if any)
+        const lastLoggedInUsername = get(securityService.get(), 'userInfo.userName');
+        this.notifyInflight(variable, true);
+        variable.promise = securityService.appLogin(params, (response) => {
+            // Closing login dialog after successful login
+            dialogService.close('CommonLoginDialog');
+            /*
+             * Get fresh security config
+             * Get App variables. if not loaded
+             * Update loggedInUser variable with new user details
+             */
+            appManager.reloadAppData().
+                then((config) => {
+                // EVENT: ON_RESULT
+                initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, get(config, 'userInfo'));
+                // EVENT: ON_PREPARESETDATA
+                newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, get(config, 'userInfo'));
+                if (newDataSet) {
+                    // setting newDataSet as the response to service variable onPrepareSetData
+                    set(config, 'userInfo', newDataSet);
+                }
+                // hide the spinner after all the n/w calls are completed
+                this.notifyInflight(variable, false, response);
+                triggerFn(success);
+                setTimeout(() => {
+                    // EVENT: ON_SUCCESS
+                    initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, get(config, 'userInfo'));
+                    /* handle navigation if defaultSuccessHandler on variable is true */
+                    if (variable.useDefaultSuccessHandler) {
+                        const isSameUserReloggedIn = lastLoggedInUsername === params['j_username'];
+                        // if first time user logging in or same user re-logging in, execute n/w calls failed before logging in
+                        if (!lastLoggedInUsername || isSameUserReloggedIn) {
+                            appManager.executeSessionFailureRequests();
+                        }
+                        // get redirectTo page from URL and remove it from URL
+                        const redirectPage = securityService.getCurrentRouteQueryParam('redirectTo'), noRedirect = appManager.noRedirect();
+                        // Get query params(page params of page being redirected to) and append to the URL after login.
+                        const queryParamsObj = securityService.getRedirectedRouteQueryParams();
+                        // The redirectTo param isn't required after login
+                        if (queryParamsObj.redirectTo) {
+                            delete queryParamsObj.redirectTo;
+                        }
+                        appManager.noRedirect(false);
+                        // first time login
+                        if (!lastLoggedInUsername) {
+                            // if redirect page found, navigate to it.
+                            if (!isEmpty(redirectPage)) {
+                                routerService.navigate([`/${redirectPage}`], { queryParams: queryParamsObj });
+                            }
+                            else if (!noRedirect) {
+                                // simply reset the URL, route handling will take care of page redirection
+                                routerService.navigate([`/`]);
+                            }
+                        }
+                        else {
+                            // login after a session timeout
+                            // if redirect page found and same user logs in again, just navigate to redirect page
+                            if (!isEmpty(redirectPage)) {
+                                // same user logs in again, just redirect to the redirectPage
+                                if (lastLoggedInUsername === params['j_username']) {
+                                    routerService.navigate([`/${redirectPage}`], { queryParams: queryParamsObj });
+                                }
+                                else {
+                                    // different user logs in, reload the app and discard the redirectPage
+                                    this.redirectToAppBasePath();
+                                }
+                            }
+                            else {
+                                const securityConfig = securityService.get(), sessionTimeoutLoginMode = get(securityConfig, 'loginConfig.sessionTimeout.type') || 'PAGE';
+                                // if in dialog mode and a new user logs in OR login happening through page, reload the app
+                                if (!isSameUserReloggedIn || sessionTimeoutLoginMode !== 'DIALOG') {
+                                    this.redirectToAppBasePath();
+                                }
+                            }
+                        }
+                    }
+                    // EVENT: ON_CAN_UPDATE
+                    initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, get(config, 'userInfo'));
+                });
+            });
+        }, (e) => {
+            // EVENT: ON_RESULT
+            initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, e);
+            this.notifyInflight(variable, false, e);
+            const errorMsg = e.error || 'Invalid credentials.';
+            const xhrObj = e.details;
+            /* if in RUN mode, trigger error events associated with the variable */
+            if (CONSTANTS.isRunMode) {
+                initiateCallback('onError', variable, errorMsg, xhrObj, true);
+            }
+            triggerFn(error, errorMsg, xhrObj);
+            // EVENT: ON_CAN_UPDATE
+            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, e);
+        });
+    }
+}
+
+class LogoutActionManager extends BaseActionManager {
+    logout(variable, options, success, error) {
+        let handleError, redirectPage, output, newDataSet;
+        handleError = function (msg, details, xhrObj) {
+            /* if in RUN mode, trigger error events associated with the variable */
+            if (!CONSTANTS.isStudioMode) {
+                initiateCallback('onError', variable, msg, xhrObj);
+            }
+            triggerFn(error, msg, xhrObj);
+        };
+        // EVENT: ON_BEFORE_UPDATE
+        output = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, null);
+        if (output === false) {
+            triggerFn(error);
+            return;
+        }
+        securityService.isAuthenticated(isAuthenticated => {
+            if (isAuthenticated) {
+                this.notifyInflight(variable, true);
+                variable.promise = securityService.appLogout(response => {
+                    let redirectUrl = response.body;
+                    redirectUrl = getValidJSON(redirectUrl);
+                    // Reset Security Config.
+                    // $rootScope.isUserAuthenticated = false;
+                    appManager.reloadAppData().
+                        then(() => {
+                        this.notifyInflight(variable, false, redirectUrl);
+                        // EVENT: ON_RESULT
+                        initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, redirectUrl);
+                        // EVENT: ON_PREPARESETDATA
+                        newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, redirectUrl);
+                        if (newDataSet) {
+                            // setting newDataSet as the response to service variable onPrepareSetData
+                            redirectUrl = newDataSet;
+                        }
+                        setTimeout(() => {
+                            // EVENT: ON_SUCCESS
+                            initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, redirectUrl);
+                            // EVENT: ON_CAN_UPDATE
+                            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, redirectUrl);
+                        });
+                    });
+                    // In case of CAS response will be the redirectUrl
+                    if (redirectUrl && redirectUrl.result) {
+                        window.location.href = redirectUrl.result;
+                    }
+                    else if (variable.useDefaultSuccessHandler) {
+                        redirectPage = variable.redirectTo;
+                        /* backward compatibility (index.html/login.html may be present in older projects) */
+                        if (!redirectPage || redirectPage === 'login.html' || redirectPage === 'index.html') {
+                            redirectPage = '';
+                        }
+                        routerService.navigate([`/${redirectPage}`]);
+                        // do not reload the mobile app.
+                        setTimeout(() => {
+                            // reloading in timeout as, firefox and safari are not updating the url before reload(WMS-7887)
+                            window.location.reload();
+                        });
+                    }
+                    triggerFn(success);
+                }, handleError);
+            }
+            else {
+                handleError('No authenticated user to logout.');
+            }
+        }, (err) => {
+            this.notifyInflight(variable, false, err);
+            handleError(err);
+        });
+    }
+}
+
+const performAuthorization = (url, providerId, onSuccess, onError, securityObj) => {
+    oauthService.perfromOAuthorization(url, providerId, onSuccess, onError, securityObj, appManager.getCustomUrlScheme(), appManager.getDeployedURL());
+};
+const getAccessToken = (provider, checkLoaclStorage) => {
+    return oauthService.getAccessToken(provider, checkLoaclStorage);
+};
+const removeAccessToken = (provider) => {
+    oauthService.removeAccessToken(provider);
+};
+
+class PaginationUtils {
+    /**
+     * Modifies the query values with the pagination info which is retrieved from the previous API response.
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param paginationInfo has metadata of the variable pagination data
+     * @returns {void} This method does not return anything
+     */
+    static setPaginationQueryParams(variable, operationInfo, paginationInfo) {
+        operationInfo.parameters.forEach(element => {
+            // pagination input information varies based on the type
+            let inputParam;
+            if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+                inputParam = 'offset';
+            }
+            else {
+                inputParam = 'page';
+            }
+            // modifies query values based on the pagination of variable
+            // compare parameter name with the input parameter's starting naming key (ex: channelcontext in channelcontext.pagination)
+            if (element.name === paginationInfo.input[inputParam].split('.')[0]) {
+                element.sampleValue = variable.pagination['page'];
+            }
+            else if (element.name === paginationInfo.input.size.split('.')[0]) {
+                element.sampleValue = variable.pagination['size'];
+            }
+        });
+    }
+    /**
+     * Sets pagination on the variable based on the response of the triggered api call.
+     * @param variable withholds variable information
+     * @param response has data of the api call's response
+     * @param options has info of the api's query params
+     * @returns {void} This method does not return anything
+     */
+    static setVariablePagination(variable, response, options) {
+        if (!variable.pagination) {
+            variable.pagination = {
+                empty: false
+            };
+        }
+        variable.pagination['size'] = response.size;
+        variable.pagination['page'] = response.page || 0;
+        variable.pagination['totalElements'] = response.totalElements;
+        variable.pagination['numberOfElements'] = variable.pagination['size'];
+        variable.pagination['number'] = options['page'] ? options['page'] - 1 : 0;
+        /**
+         * Deduce totalPages from totalElements by size.
+         * If the total elements are evenly split among the pages, assign the same to totalPages
+         * Else assign totalPages + 1
+         */
+        variable.pagination['totalPages'] = variable.pagination['totalElements'] / variable.pagination['size'];
+        if (variable.pagination['totalElements'] % variable.pagination['size'] === 0) {
+            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']);
+        }
+        else {
+            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']) + 1;
+        }
+        // If pagination type is cursor, fill next & prev
+        if (response.next) {
+            variable.pagination['next'] = response.next;
+            variable.pagination['prev'] = response.prev;
+            variable.pagination['last'] = response.next ? false : true;
+            variable.pagination['first'] = response.prev ? false : true;
+        }
+        else {
+            variable.pagination['first'] = variable.pagination['page'] <= 1 ? true : false;
+            // calculate last based on current page index against total pages
+            variable.pagination['last'] = response.hasMoreItems === '' ? !(variable.pagination['page'] < variable.pagination['totalPages']) : !response.hasMoreItems;
+        }
+    }
+    /**
+     * Resolves the expression given in pagination metadata's output
+     * @param item has value of each key which is inside output pagination metadata
+     * @param response has data of the api call's response
+     * @param resHeaders has data of the api call's response headers
+     * @param res holds the information of pagination which has to be stored on the variable
+     * @param key has key name against which data has to be stored in pagination
+     * @returns {void} This method does not return anything
+     */
+    static setPaginationItems(item, response, res, key, resHeaders) {
+        // if the item has body, resolve the expression against the response
+        if (startsWith(item, '$body')) {
+            const bodyKey = item.replace('$body.', '');
+            try {
+                res[key] = jmespath.search(response, bodyKey);
+            }
+            catch {
+                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+            }
+        }
+        else if (startsWith(item, '$header')) { // if the item has header, resolve the expression against the response headers
+            const headerKey = item.replace('$header.', '');
+            const headers = Object.fromEntries(resHeaders.headers);
+            const headerParams = headerKey.split('.');
+            try {
+                res[key] = jmespath.search(headers, headerParams[0].toLowerCase());
+            }
+            catch {
+                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+            }
+            if (res[key]?.length) {
+                let headerVal = res[key].join();
+                if (headerParams.length === 1) {
+                    /**
+                     * If the headerParams has only 1 key (which is not an object) name assing headerVal to the res[key]
+                     */
+                    res[key] = headerVal;
+                }
+                else {
+                    /**
+                     * If the headerParams has more than 1 key (an object), parse the stringified headerVal which is an object
+                     * Resolve the expression against headerVal object amd assign it to res[key]
+                     */
+                    let keyName = headerParams.slice(1).join('.');
+                    const headerResp = JSON.parse(headerVal);
+                    const specialChar = /[!@#$%^&*()+\=\[\]{};':"\\|,<>\/?]+/;
+                    if (specialChar.test(keyName)) {
+                        // If key name has expression (ex: comparission expression)
+                        // add root key name to keyName for JMES to resolve the expression
+                        keyName = 'headerResp.' + keyName;
+                    }
+                    try {
+                        res[key] = jmespath.search(headerResp, keyName);
+                    }
+                    catch {
+                        console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Return the pagination information of the service based on its existence on swagger or on the variable
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @returns {object} This method return pagination metadata
+     */
+    static getPaginationInfo(operationInfo, variable) {
+        if (operationInfo?.paginationInfo) {
+            return operationInfo.paginationInfo;
+        }
+        else {
+            return variable._paginationConfig;
+        }
+    }
+    /**
+     * Set query params with the pagination info, if pagination metadata is present in query params
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param options has info of the api's query params
+     * @returns {void} This method does not return anything
+     */
+    static checkPaginationAtQuery(operationInfo, variable, options) {
+        const paginationInfo = this.getPaginationInfo(operationInfo, variable);
+        // If page is not first, pagination is present on the variable and paginationInfo's input meta has size set pagination in query params
+        const hasPagination = options && options['page'] && paginationInfo?.input.size && variable.pagination;
+        if (!hasPagination) {
+            return;
+        }
+        let inputParam;
+        // if pagination type is offset, asssign inputParam to offset else page
+        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+            inputParam = 'offset';
+        }
+        else {
+            inputParam = 'page';
+        }
+        const paramName = paginationInfo.input[inputParam].split('.')[0];
+        const paramObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === paramName;
+        });
+        // check if the variable has query params and they are not empty
+        if (!isEmpty(variable.dataBinding) && paramObj && paramObj.parameterType === 'query') {
+            /**
+             * For pagination type other than offset, assign page which is recieved from options
+             * For offset type, calculate page from size and options[page]
+             */
+            if (!paginationInfo.output?.page && paginationInfo.type !== 'offset') {
+                variable.pagination['page'] = options['page'];
+            }
+            else {
+                variable.pagination['page'] = this.getOffsetInfo(variable, options);
+            }
+            this.setPaginationQueryParams(variable, operationInfo, paginationInfo);
+        }
+    }
+    /**
+     * Deduces the offset information from the size and page params
+     * @param variable withholds variable information
+     * @param options has info of the api's query params
+     * @returns {object} Returns the next offset number
+     */
+    static getOffsetInfo(variable, options) {
+        return variable.pagination['size'] * (options['page'] ? (options['page'] - 1) : 1);
+    }
+    /**
+     * Sets Pagination data on the request information
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param options has info of the api's query params
+     * @param paginationInfo has pagination information of the variable
+     * @param headers has request headers
+     * @param requestBody has request body
+     * @param url has request url
+     * @returns {object} Returns the request object which has pagination info
+     */
+    static setPaginationAtReq(paginationInfo, operationInfo, variable, headers, requestBody, url, options) {
+        let reqObj = {};
+        let inputParam;
+        let resObj = {};
+        // pagination input information varies based on the type
+        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+            inputParam = 'offset';
+        }
+        else {
+            inputParam = 'page';
+        }
+        const paramName = paginationInfo.input[inputParam].split('.')[0];
+        // check if paramName is present in parameters of operation info
+        const paramObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === paramName;
+        });
+        // set page/offset and size from pagination if matched parameter's type is header
+        if (paramObj?.parameterType === 'header') {
+            set(reqObj, paginationInfo.input[inputParam], variable.pagination['page']);
+            set(reqObj, paginationInfo.input.size, variable.pagination['size']);
+            headers[paramName] = JSON.stringify(reqObj[paramName]);
+            resObj['headers'] = headers;
+        }
+        else if (paramObj?.parameterType === 'body') {
+            // set page/offset and size from pagination if matched parameter's type is body
+            // assign bodyVal to updated pagination info object
+            const bodyVal = JSON.parse(paramObj.sampleValue);
+            const bodyParam = paginationInfo.input[inputParam].split('.')[1];
+            if (bodyVal && bodyVal[bodyParam]) {
+                const inputBodyParam = paginationInfo.input[inputParam].split('.').splice(1).join('.');
+                if (inputParam !== 'offset') {
+                    set(reqObj, inputBodyParam, variable.pagination['page']);
+                }
+                else {
+                    set(reqObj, inputBodyParam, this.getOffsetInfo(variable, options));
+                }
+                set(reqObj, paginationInfo.input.size.split('.').splice(1).join('.'), variable.pagination['size']);
+                bodyVal[bodyParam] = reqObj[bodyParam];
+                requestBody = JSON.stringify(bodyVal);
+                resObj['requestBody'] = requestBody;
+            }
+        }
+        else if (variable.pagination.next && paramObj) {
+            /**
+             * For cursor type pagination, if pagination info is present in the path
+             * Based on whether user clicks on the next or prev button modify the url
+             */
+            if (paramObj.parameterType === 'path') {
+                const urlParams = operationInfo.relativePath.split('/'), paramConfig = '{' + paramObj.name + '}', paramIndex = urlParams.indexOf(paramConfig);
+                let invokeUrl;
+                if (variable.pagination.isNext) {
+                    invokeUrl = variable.pagination.next.split('/');
+                }
+                else {
+                    invokeUrl = variable.pagination.prev.split('/');
+                }
+                let urlPathParmas;
+                let urlPath;
+                if (operationInfo.directPath) { // For direct path, as url has hostname, derivate pathname using URL object
+                    urlPath = new URL(url);
+                    urlPathParmas = urlPath.pathname.split('/');
+                    urlPathParmas[paramIndex] = invokeUrl[paramIndex];
+                    urlPath.pathname = urlPathParmas.join('/');
+                    url = urlPath.href;
+                    resObj['url'] = url;
+                }
+                else { // Else modify the url with index as +1 (following proxy pattern)
+                    urlPathParmas = url.split('/');
+                    urlPathParmas[paramIndex + 1] = invokeUrl[paramIndex];
+                    url = urlPathParmas.join('/');
+                    resObj['url'] = url;
+                }
+            }
+            else if (paramObj.parameterType === 'query') {
+                /**
+                 * For cursor type pagination, if pagination info is present in the query
+                 * Based on whether user clicks on the next or prev button modify the url's query params
+                 */
+                const urlParams = url.split('?');
+                let invokeUrl;
+                if (variable.pagination.isNext) {
+                    invokeUrl = variable.pagination.next.split('?');
+                }
+                else {
+                    invokeUrl = variable.pagination.prev.split('?');
+                }
+                urlParams[1] = invokeUrl[1];
+                url = urlParams.join('?');
+                resObj['url'] = url;
+            }
+        }
+        return resObj;
+    }
+    /**
+     * Sets the pagination info recieved from api's response in the res object
+     * @param operationInfo has metadata of the variable
+     * @param res holds the information of pagination which has to be stored on the variable
+     * @param paramName has key name against which data has to be stored in pagination
+     * @param variable withholds variable information
+     * @returns {void} This method does not return anything
+     */
+    static setParameterVal(paramName, res, operationInfo, variable) {
+        const paginationInfo = this.getPaginationInfo(operationInfo, variable);
+        const param = paginationInfo.input[paramName].split('.')[0];
+        const sizeObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === param;
+        });
+        res[paramName] = result(sizeObj, 'sampleValue');
+    }
+    /**
+     * Creates res object from the response recieved from the api triggered
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param paginationInfo has metadata of the variable's pagination
+     * @param response has data of the api call's response
+     * @param options has info of the api's query params
+     * @param resHeaders has data of the api call's response headers
+     * @returns {object} An object which holds the information of pagination which has to be stored on the variable
+     */
+    static generatePaginationRes(operationInfo, paginationInfo, response, resHeaders, options, variable) {
+        let res = {};
+        const resOutput = paginationInfo.output;
+        // If pagination type is not cursor, create the following metadata
+        if (!resOutput?.next) {
+            /**
+             * If size is present in the pagination's output metadata deduce size from api's response
+             * Else deduce size from the pagination's input metadata size key
+             */
+            if (resOutput?.size) {
+                this.setPaginationItems(resOutput.size, response, res, 'size', resHeaders);
+            }
+            else {
+                this.setParameterVal('size', res, operationInfo, variable);
+            }
+            /**
+             * If page is present in the pagination's output metadata deduce page from api's response
+             * Else deduce page from the pagination's input metadata page key
+             */
+            if (resOutput?.page) {
+                this.setPaginationItems(resOutput.page, response, res, 'page', resHeaders);
+            }
+            else if (paginationInfo.type !== 'offset') {
+                this.setParameterVal('page', res, operationInfo, variable);
+            }
+            /**
+             * If totalElements has $minValue in it, set totalElements as $minValue
+             * If the rendered elements are greater than $minValue, set totalElements as Number of elements rendered + 1
+
+             * If totalElements is present in the pagination's output metadata deduce totalElements from api's response
+
+             * If Pagination type is offset, deduce totalElements from size and options[page] else deduce from size and res[page]
+                */
+            if (startsWith(resOutput?.totalElements, '$minValue')) {
+                const totalEl = resOutput.totalElements.replace('$minValue=', '');
+                const pageParam = res['page'] ? res['page'] : options['page'];
+                const elRendered = res['size'] * pageParam;
+                if (!variable.pagination || variable.pagination['totalElements'] > elRendered) {
+                    res['totalElements'] = parseInt(totalEl);
+                }
+                else {
+                    res['totalElements'] = elRendered + 1;
+                }
+            }
+            else if (resOutput?.totalElements) {
+                this.setPaginationItems(resOutput.totalElements, response, res, 'totalElements', resHeaders);
+            }
+            else {
+                if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+                    res['totalElements'] = (res['size'] * (options['page'] ? options['page'] : 1)) + 1;
+                }
+                else {
+                    res['totalElements'] = (res['size'] * res['page']) + 1;
+                }
+            }
+            /**
+             * If hasMoreItems is present in the pagination's output metadata deduce hasMoreItems from api's response
+             * Else assign it as empty which will be calculated at pagination object generation
+             */
+            if (resOutput?.hasMoreItems) {
+                this.setPaginationItems(resOutput.hasMoreItems, response, res, 'hasMoreItems', resHeaders);
+            }
+            else {
+                res['hasMoreItems'] = '';
+            }
+        }
+        else if (resOutput) { // For cursor type pagination set next and prev keys in res object
+            this.setPaginationItems(resOutput.next, response, res, 'next', resHeaders);
+            this.setPaginationItems(resOutput.prev, response, res, 'prev', resHeaders);
+        }
+        return res;
+    }
+}
+
+/**
+ * returns true if a Service variable is:
+ *  - for a query/procedure
+ *  - performs a PUT/POST operation, i.e, takes a Request Body as input
+ * @param variable
+ * @returns {any}
+ */
+const isBodyTypeQueryOrProcedure = (variable) => {
+    return (includes(['QueryExecution', 'ProcedureExecution'], variable.controller)) && (includes(['put', 'post'], variable.operationType));
+};
+/**
+ * returns true if the variable is a Query service variable
+ * @param {string} controller
+ * @param {string} serviceType
+ * @returns {boolean}
+ */
+const isQueryServiceVar = (controller, serviceType) => {
+    return controller === VARIABLE_CONSTANTS.CONTROLLER_TYPE.QUERY && serviceType === VARIABLE_CONSTANTS.SERVICE_TYPE.DATA;
+};
+/**
+ * Append given value to the formdata
+ * @param formData
+ * @param param - Param from which value has to be taken
+ * @param paramValue - Value which is to be appended to formdata
+ */
+const getFormData = (formData, param, paramValue) => {
+    const paramType = toLower(extractType(get(param, 'items.type') || param.type)), paramContentType = CONSTANTS.isStudioMode ? param['x-WM-CONTENT_TYPE'] : param.contentType;
+    if (isFileUploadSupported()) {
+        if ((paramType !== 'file') && (paramContentType === 'string' || !paramContentType)) {
+            if (isObject(paramValue)) {
+                paramValue = JSON.stringify(paramValue);
+            }
+            formData.append(param.name, paramValue);
+        }
+        else {
+            if (isArray(paramValue) && paramType === 'file') {
+                forEach(paramValue, function (fileObject) {
+                    formData.append(param.name, (fileObject && fileObject.content) || getBlob(fileObject), fileObject.name);
+                });
+            }
+            else {
+                formData.append(param.name, getBlob(paramValue, paramContentType), paramValue && paramValue.name);
+            }
+        }
+        return formData;
+    }
+};
+/**
+ * Check for missing required params and format the date/time param values
+ * @param inputData
+ * @param params
+ * @returns {{requestBody: {}; missingParams: any[]}}
+ */
+const processRequestBody = (inputData, params) => {
+    const requestBody = {}, missingParams = [];
+    let paramValue;
+    forEach(params, function (param) {
+        paramValue = get(inputData, param.name);
+        if (!isUndefined(paramValue) && paramValue !== '' && paramValue !== null && !param.readOnly) {
+            paramValue = isDateTimeType(param.type) ? formatDate(paramValue, param.type) : paramValue;
+            // Construct ',' separated string if param is not array type but value is an array
+            if (isArray(paramValue) && toLower(extractType(param.type)) === 'string') {
+                paramValue = join(paramValue, ',');
+            }
+            requestBody[param.name] = paramValue;
+        }
+        else if (param.required) {
+            missingParams.push(param.name || param.id);
+        }
+    });
+    return {
+        'requestBody': requestBody,
+        'missingParams': missingParams
+    };
+};
+/**
+ * Done only for HTTP calls made via the proxy server
+ * Goes though request headers, appends 'X-' to certain headers
+ * these headers need not be processed at proxy server and should directly be passed to the server
+ * e.g. Authorization, Cookie, etc.
+ * @param headers
+ * @returns {{}}
+ */
+const cloakHeadersForProxy = (headers) => {
+    const _headers = {}, UNCLOAKED_HEADERS = VARIABLE_CONSTANTS.REST_SERVICE.UNCLOAKED_HEADERS, CLOAK_PREFIX = VARIABLE_CONSTANTS.REST_SERVICE.PREFIX.CLOAK_HEADER_KEY;
+    forEach(headers, function (val, key) {
+        if (includes(UNCLOAKED_HEADERS, key.toUpperCase())) {
+            _headers[key] = val;
+        }
+        else {
+            _headers[CLOAK_PREFIX + key] = val;
+        }
+    });
+    return _headers;
+};
+class ServiceVariableUtils {
+    /**
+     * prepares the HTTP request info for a Service Variable
+     * @param variable
+     * @param operationInfo
+     * @param inputFields
+     * @returns {any}
+     */
+    static constructRequestParams(variable, operationInfo, inputFields, options) {
+        variable = variable || {};
+        // operationInfo is specifically null for un_authorized access
+        if (operationInfo === null) {
+            return {
+                'error': {
+                    'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.USER_UNAUTHORISED,
+                    'message': VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.USER_UNAUTHORISED,
+                    'field': '_wmServiceOperationInfo'
+                }
+            };
+        }
+        else if (isEmpty(operationInfo)) {
+            return {
+                'error': {
+                    'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.METADATA_MISSING,
+                    'message': VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.METADATA_MISSING,
+                    'field': '_wmServiceOperationInfo'
+                }
+            };
+        }
+        else if (operationInfo && operationInfo.invalid) {
+            return {
+                'error': {
+                    'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.CRUD_OPERATION_MISSING,
+                    'message': VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.CRUD_OPERATION_MISSING,
+                    'field': '_wmServiceOperationInfo'
+                }
+            };
+        }
+        const directPath = operationInfo.directPath || '', relativePath = operationInfo.basePath ? operationInfo.basePath + operationInfo.relativePath : operationInfo.relativePath, isBodyTypeQueryProcedure = isBodyTypeQueryOrProcedure(variable);
+        let queryParams = '', bodyInfo, headers = {}, requestBody, url, requiredParamMissing = [], target, pathParamRex, invokeParams, authDetails = null, uname, pswd, method, formData, isProxyCall, paramValueInfo, params, securityDefnObj, accessToken, withCredentials;
+        function getFormDataObj() {
+            if (formData) {
+                return formData;
+            }
+            formData = new FormData();
+            return formData;
+        }
+        securityDefnObj = get(operationInfo.securityDefinitions, '0');
+        if (securityDefnObj) {
+            switch (securityDefnObj.type) {
+                case VARIABLE_CONSTANTS.REST_SERVICE.SECURITY_DEFN.OAUTH2:
+                    accessToken = getAccessToken(securityDefnObj[VARIABLE_CONSTANTS.REST_SERVICE.OAUTH_PROVIDER_KEY], null);
+                    if (accessToken) {
+                        headers[VARIABLE_CONSTANTS.REST_SERVICE.AUTH_HDR_KEY] = VARIABLE_CONSTANTS.REST_SERVICE.PREFIX.AUTH_HDR_VAL.OAUTH + ' ' + accessToken;
+                    }
+                    else {
+                        return {
+                            'error': {
+                                'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.NO_ACCESSTOKEN,
+                                'message': VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.NO_ACCESSTOKEN
+                            },
+                            'securityDefnObj': securityDefnObj
+                        };
+                    }
+                    break;
+                case VARIABLE_CONSTANTS.REST_SERVICE.SECURITY_DEFN.BASIC:
+                    uname = inputFields['wm_auth_username'];
+                    pswd = inputFields['wm_auth_password'];
+                    if (uname && pswd) {
+                        // TODO[VIBHU]: bas64 encoding alternative.
+                        headers[VARIABLE_CONSTANTS.REST_SERVICE.AUTH_HDR_KEY] = VARIABLE_CONSTANTS.REST_SERVICE.PREFIX.AUTH_HDR_VAL.BASIC + ' ' + btoa(uname + ':' + pswd);
+                        authDetails = {
+                            'type': VARIABLE_CONSTANTS.REST_SERVICE.AUTH_TYPE.BASIC
+                        };
+                    }
+                    else {
+                        return {
+                            'error': {
+                                'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.NO_CREDENTIALS,
+                                'message': VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.NO_CREDENTIALS
+                            },
+                            'securityDefnObj': securityDefnObj
+                        };
+                    }
+                    break;
+            }
+        }
+        // set query params, if pagination info is present and the info should be present in query
+        PaginationUtils.checkPaginationAtQuery(operationInfo, variable, options);
+        operationInfo.proxySettings = operationInfo.proxySettings || { web: true, mobile: false };
+        method = operationInfo.httpMethod || operationInfo.methodType;
+        isProxyCall = (function () {
+            return operationInfo.proxySettings.web;
+        }());
+        withCredentials = operationInfo.proxySettings.withCredentials;
+        url = isProxyCall ? relativePath : directPath;
+        /* loop through all the parameters */
+        forEach(operationInfo.parameters, function (param) {
+            // Set params based on current workspace
+            function setParamsOfChildNode() {
+                if (inputFields) {
+                    // specific case for body type query/procedure variable with query params
+                    if (inputFields[param.name] && isObject(inputFields[param.name])) {
+                        paramValueInfo = inputFields[param.name];
+                    }
+                    else {
+                        paramValueInfo = inputFields;
+                    }
+                    params = get(operationInfo, ['definitions', param.type]);
+                }
+                else {
+                    // For Api Designer
+                    paramValueInfo = paramValue || {};
+                    params = param.children;
+                }
+            }
+            let paramValue = param.sampleValue;
+            if ((isDefined(paramValue) && paramValue !== null && paramValue !== '') || (isBodyTypeQueryProcedure && param.type !== 'file')) {
+                // Format dateTime params for dataService variables
+                if (variable.serviceType === VARIABLE_CONSTANTS.SERVICE_TYPE.DATA && isDateTimeType(param.type)) {
+                    paramValue = formatDate(paramValue, param.type);
+                }
+                // Construct ',' separated string if param is not array type but value is an array
+                if (isArray(paramValue) && toLower(extractType(param.type)) === 'string' && variable.serviceType === VARIABLE_CONSTANTS.SERVICE_TYPE.DATA) {
+                    paramValue = join(paramValue, ',');
+                }
+                switch (param.parameterType.toUpperCase()) {
+                    case 'QUERY':
+                        // Ignore null valued query params for queryService variable
+                        if (isNull(paramValue) && isQueryServiceVar(variable.controller, variable.serviceType)) {
+                            break;
+                        }
+                        if (!queryParams) {
+                            queryParams = '?' + param.name + '=' + encodeURIComponent(paramValue);
+                        }
+                        else {
+                            queryParams += '&' + param.name + '=' + encodeURIComponent(paramValue);
+                        }
+                        break;
+                    case 'PATH':
+                        /* replacing the path param based on the regular expression in the relative path */
+                        pathParamRex = new RegExp('\\s*\\{\\s*' + param.name + '(:\\.\\+)?\\s*\\}\\s*');
+                        url = url.replace(pathParamRex, paramValue);
+                        break;
+                    case 'HEADER':
+                        headers[param.name] = paramValue;
+                        break;
+                    case 'BODY':
+                        // For post/put query methods wrap the input
+                        if (isBodyTypeQueryProcedure) {
+                            setParamsOfChildNode();
+                            bodyInfo = processRequestBody(paramValueInfo, params);
+                            requestBody = bodyInfo.requestBody;
+                            requiredParamMissing = concat(requiredParamMissing, bodyInfo.missingParams);
+                        }
+                        else {
+                            requestBody = paramValue;
+                        }
+                        break;
+                    case 'FORMDATA':
+                        if (isBodyTypeQueryProcedure && param.name === SWAGGER_CONSTANTS.WM_DATA_JSON) {
+                            setParamsOfChildNode();
+                            // Process query/procedure formData non-file params params
+                            bodyInfo = processRequestBody(paramValueInfo, params);
+                            requestBody = getFormData(getFormDataObj(), param, bodyInfo.requestBody);
+                            requiredParamMissing = concat(requiredParamMissing, bodyInfo.missingParams);
+                        }
+                        else {
+                            requestBody = getFormData(getFormDataObj(), param, paramValue);
+                        }
+                        break;
+                }
+            }
+            else if (param.required) {
+                requiredParamMissing.push(param.name || param.id);
+            }
+        });
+        // if required param not found, return error
+        if (requiredParamMissing.length) {
+            return {
+                'error': {
+                    'type': VARIABLE_CONSTANTS.REST_SERVICE.ERR_TYPE.REQUIRED_FIELD_MISSING,
+                    'field': requiredParamMissing.join(','),
+                    'message': replace$1(VARIABLE_CONSTANTS.REST_SERVICE.ERR_MSG.REQUIRED_FIELD_MISSING, [requiredParamMissing.join(',')]),
+                    'skipDefaultNotification': true
+                }
+            };
+        }
+        // Setting appropriate content-Type for request accepting request body like POST, PUT, etc
+        if (!includes(WS_CONSTANTS.NON_BODY_HTTP_METHODS, toUpper(method))) {
+            /*Based on the formData browser will automatically set the content type to 'multipart/form-data' and webkit boundary*/
+            if (!(operationInfo.consumes && (operationInfo.consumes[0] === WS_CONSTANTS.CONTENT_TYPES.MULTIPART_FORMDATA))) {
+                headers['Content-Type'] = (operationInfo.consumes && operationInfo.consumes[0]) || 'application/json';
+            }
+        }
+        // if the consumes has application/x-www-form-urlencoded and
+        // if the http request of given method type can have body send the queryParams as Form Data
+        if (includes(operationInfo.consumes, WS_CONSTANTS.CONTENT_TYPES.FORM_URL_ENCODED)
+            && !includes(WS_CONSTANTS.NON_BODY_HTTP_METHODS, (method || '').toUpperCase())) {
+            // remove the '?' at the start of the queryParams
+            if (queryParams) {
+                requestBody = (requestBody ? requestBody + '&' : '') + queryParams.substring(1);
+            }
+            headers['Content-Type'] = WS_CONSTANTS.CONTENT_TYPES.FORM_URL_ENCODED;
+        }
+        else {
+            url += queryParams;
+        }
+        /*
+         * for proxy calls:
+         *  - cloak the proper headers (required only for REST services)
+         *  - prepare complete url from relativeUrl
+         */
+        if (isProxyCall) {
+            // avoiding cloakHeadersForProxy when the method is invoked from apidesigner.
+            headers = (variable.serviceType !== VARIABLE_CONSTANTS.SERVICE_TYPE.REST && variable.serviceType !== VARIABLE_CONSTANTS.SERVICE_TYPE.OPENAPI) || operationInfo.skipCloakHeaders ? headers : cloakHeadersForProxy(headers);
+            if (variable.getPrefabName() && VARIABLE_CONSTANTS.REST_SUPPORTED_SERVICES.indexOf(variable.serviceType) !== -1) {
+                /* if it is a prefab variable (used in a normal project), modify the url */
+                url = 'prefabs/' + variable.getPrefabName() + url;
+                target = 'invokePrefabRestService';
+            }
+            else if (!variable.getPrefabName()) {
+                url = 'services' + url;
+            }
+            url = $rootScope.project.deployedUrl + url;
+        }
+        // If pagination info exists, process info in request headers or body based on the metadata
+        const paginationInfo = PaginationUtils.getPaginationInfo(operationInfo, variable);
+        if (paginationInfo && variable.pagination) {
+            const resp = PaginationUtils.setPaginationAtReq(paginationInfo, operationInfo, variable, headers, requestBody, url, options);
+            if (resp) {
+                if (resp['headers']) {
+                    headers = resp['headers'];
+                }
+                else if (resp['requestBody']) {
+                    requestBody = resp['requestBody'];
+                }
+                else if (resp['url']) {
+                    url = resp['url'];
+                }
+            }
+        }
+        /*creating the params needed to invoke the service. url is generated from the relative path for the operation*/
+        invokeParams = {
+            'projectID': $rootScope.project.id,
+            'url': url,
+            'target': target,
+            'method': method,
+            'headers': headers,
+            'data': requestBody,
+            'authDetails': authDetails,
+            'isDirectCall': !isProxyCall,
+            'isExtURL': variable.serviceType === VARIABLE_CONSTANTS.SERVICE_TYPE.REST,
+            'withCredentials': withCredentials
+        };
+        return invokeParams;
+    }
+    static isFileUploadRequest(variable) {
+        // temporary fix, have to find proper solution for deciding weather to upload file through variable
+        return variable.service === 'FileService' && variable.operation === 'uploadFile';
+    }
+    /**
+     * This method returns array of query param names for variable other then page,size,sort
+     * @params {params} params of the variable
+     */
+    static excludePaginationParams(params) {
+        return map(reject(params, (param) => {
+            return includes(VARIABLE_CONSTANTS.PAGINATION_PARAMS, param.name);
+        }), function (param) {
+            return param.name;
+        });
+    }
+}
+
+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$1(message) ? JSON.stringify(message) : message;
+        try {
+            socket.send(message, 0);
+        }
+        catch (error) {
+            console.error('Error sending message:', error);
+            this._onSocketError(variable, { data: error.message });
+        }
+    }
+}
+
+const managerMap = new Map(), typeToManagerMap = {
+    'Variable': BaseVariableManager,
+    'Action': BaseActionManager,
+    'wm.NavigationAction': NavigationActionManager,
+    'wm.NotificationAction': NotificationActionManager,
+    'wm.LoginAction': LoginActionManager,
+    'wm.LogoutAction': LogoutActionManager,
+    'wm.WebSocketVariable': WebSocketVariableManager
+};
+class VariableManagerFactory {
+    static get(type) {
+        return managerMap.has(type) ?
+            managerMap.get(type) :
+            managerMap.set(type, new typeToManagerMap[type]()).get(type);
+    }
+}
+
+const getManager$4 = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.NAVIGATION);
+};
+class NavigationAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    invoke(options) {
+        getManager$4().invoke(this, options);
+    }
+    // legacy method.
+    navigate(options) {
+        this.invoke(options);
+    }
+    init() {
+        // static property bindings
+        getManager$4().initBinding(this, 'dataBinding', 'dataBinding');
+        // dynamic property bindings (e.g. page params)
+        getManager$4().initBinding(this, 'dataSet', 'dataSet');
+    }
+}
+
+const getManager$3 = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.NOTIFICATION);
+};
+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$3().notify(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        this.notify(options, success, error);
+    }
+    getMessage() {
+        return getManager$3().getMessage(this);
+    }
+    setMessage(text) {
+        return getManager$3().setMessage(this, text);
+    }
+    clearMessage() {
+        return getManager$3().setMessage(this, '');
+    }
+    getOkButtonText() {
+        return getManager$3().getOkButtonText(this);
+    }
+    setOkButtonText(text) {
+        return getManager$3().setOkButtonText(this, text);
+    }
+    getToasterDuration() {
+        return getManager$3().getToasterDuration(this);
+    }
+    setToasterDuration(duration) {
+        return getManager$3().setToasterDuration(this, duration);
+    }
+    getToasterClass() {
+        return getManager$3().getToasterClass(this);
+    }
+    setToasterClass(classText) {
+        return getManager$3().setToasterClass(this, classText);
+    }
+    getToasterPosition() {
+        return getManager$3().getToasterPosition(this);
+    }
+    setToasterPosition(position) {
+        return getManager$3().setToasterPosition(this, position);
+    }
+    getAlertType() {
+        return getManager$3().getAlertType(this);
+    }
+    setAlertType(type) {
+        return getManager$3().setAlertType(this, type);
+    }
+    getCancelButtonText() {
+        return getManager$3().getCancelButtonText(this);
+    }
+    setCancelButtonText(text) {
+        return getManager$3().setCancelButtonText(this, text);
+    }
+    init() {
+        // static property bindings
+        getManager$3().initBinding(this, 'dataBinding', 'dataBinding');
+        // dynamic property bindings
+        getManager$3().initBinding(this, 'dataSet', 'dataSet');
+    }
+}
+
+const getManager$2 = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.LOGIN);
+};
+class LoginAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    login(options, success, error) {
+        return getManager$2().login(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        return this.login(options, success, error);
+    }
+    cancel() {
+        // TODO[VIBHU]: implement http abort logic
+    }
+    init() {
+        getManager$2().initBinding(this, 'dataBinding', 'dataBinding');
+    }
+}
+
+const getManager$1 = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.LOGOUT);
+};
+class LogoutAction extends BaseAction {
+    constructor(variable) {
+        super();
+        Object.assign(this, variable);
+    }
+    logout(options, success, error) {
+        getManager$1().logout(this, options, success, error);
+    }
+    invoke(options, success, error) {
+        this.logout(options, success, error);
+    }
+    cancel() {
+        // TODO[VIBHU]: implement http abort logic
+    }
+}
+
+const getManager = () => {
+    return VariableManagerFactory.get(VARIABLE_CONSTANTS.CATEGORY.WEBSOCKET);
+};
+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);
+    }
+}
+
+class VariableFactory {
+    static create(variable, context) {
+        let variableInstance;
+        switch (variable.category) {
+            case VARIABLE_CONSTANTS$1.CATEGORY.MODEL:
+                variableInstance = new ModelVariable(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.SERVICE:
+                variableInstance = new ServiceVariable(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.LIVE:
+                variableInstance = new LiveVariable(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.CRUD:
+                variableInstance = new CrudVariable(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.NAVIGATION:
+                variableInstance = new NavigationAction(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.NOTIFICATION:
+                variableInstance = new NotificationAction(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.LOGIN:
+                variableInstance = new LoginAction(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.LOGOUT:
+                variableInstance = new LogoutAction(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.TIMER:
+                variableInstance = new TimerAction(variable);
+                break;
+            case VARIABLE_CONSTANTS$1.CATEGORY.WEBSOCKET:
+                variableInstance = new WebSocketVariable(variable);
+        }
+        variableInstance._context = context;
+        variableInstance.__cloneable__ = false;
+        return variableInstance;
+    }
+}
+
+class MetadataService {
+    constructor($http) {
+        this.$http = $http;
+        this.CONTEXT_APP = 'app';
+    }
+    isLoaded() {
+        return this.metadataMap ? this.metadataMap.has(this.CONTEXT_APP) : false;
+    }
+    load(prefabName) {
+        let url;
+        let serviceDefFileName = prefabName ? prefabName + '-prefab-servicedefs.json' : 'app-servicedefs.json';
+        const deployedUrl = _WM_APP_PROJECT.cdnUrl + 'servicedefs/' + serviceDefFileName;
+        const previewUrl = './services/' + (prefabName ? `prefabs/${prefabName}/` : '') + 'servicedefs';
+        url = _WM_APP_PROJECT.isPreview || _WM_APP_PROPERTIES?.serviceDefSources === 'DYNAMIC' ? previewUrl : deployedUrl;
+        return new Promise((resolve, reject) => {
+            this.$http.send({ 'url': url, 'method': 'GET' }).then((response) => {
+                this.metadataMap = this.metadataMap || new Map();
+                this.providerMap = this.providerMap || new Map();
+                response.body = response.body || {};
+                this.metadataMap.set(prefabName || this.CONTEXT_APP, response.body.serviceDefs);
+                if (response.body.securityDefinitions) {
+                    this.providerMap.set(prefabName || this.CONTEXT_APP, response.body.securityDefinitions.oauthProvider);
+                }
+                resolve(response.body.serviceDefs);
+            }, reject);
+        });
+    }
+    getByOperationId(operationId, context) {
+        context = context || this.CONTEXT_APP;
+        const map = this.metadataMap.get(context);
+        return map && map[operationId];
+    }
+    // function to get Provider details from providerMap for the passed providerId
+    getByProviderId(providerId, context) {
+        context = context || this.CONTEXT_APP;
+        const map = this.providerMap.get(context);
+        return map && map[providerId];
+    }
+    getByCrudId(crudId, context) {
+        context = context || this.CONTEXT_APP;
+        const map = this.metadataMap.get(context);
+        let ops = [];
+        for (let k in map) {
+            if (map[k] && map[k].crudOperationId === crudId) {
+                ops.push(map[k]);
+            }
+        }
+        return ops;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MetadataService, deps: [{ token: i1.AbstractHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MetadataService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MetadataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AbstractHttpService }] });
+
+class Formatter {
+    format(value, format) {
+        return appManager.getPipe('date').transform(value, format);
+    }
+}
+class VariablesService {
+    constructor(httpService, metadataService, navigationService, routerService, toasterService, oAuthService, securityService, dialogService) {
+        this.httpService = httpService;
+        this.metadataService = metadataService;
+        this.navigationService = navigationService;
+        this.routerService = routerService;
+        this.toasterService = toasterService;
+        this.oAuthService = oAuthService;
+        this.securityService = securityService;
+        this.dialogService = dialogService;
+        // set external dependencies, to be used across variable classes, managers and utils
+        setDependency('http', this.httpService);
+        setDependency('metadata', this.metadataService);
+        setDependency('navigationService', this.navigationService);
+        setDependency('router', this.routerService);
+        setDependency('toaster', this.toasterService);
+        setDependency('oAuth', this.oAuthService);
+        setDependency('security', this.securityService);
+        setDependency('dialog', this.dialogService);
+        wmSetDependency('oAuth', this.oAuthService);
+        wmSetDependency('security', this.securityService);
+        wmSetDependency('metadata', this.metadataService);
+        wmSetDependency('http', this.httpService);
+    }
+    /**
+     * loop through a collection of variables/actions
+     * trigger cancel on each (of exists)
+     * @param collection
+     */
+    bulkCancel(collection) {
+        Object.keys(collection).forEach(name => {
+            const variable = collection[name];
+            if (isFunction(variable.cancel)) {
+                variable.cancel();
+            }
+        });
+    }
+    /**
+     * loops over the variable/actions collection and trigger invoke on it if startUpdate on it is true
+     * @param collection
+     */
+    triggerStartUpdate(collection) {
+        return Promise.all(Object.keys(collection)
+            .map(name => collection[name])
+            .filter(variable => variable?.startUpdate && variable.invoke)
+            .map(variable => variable.invoke()));
+    }
+    processBindExp(d, scope, variable) {
+        const root = getTarget(variable), targetNodeKey = getTargetNodeKey$1(d.target), runMode = true;
+        let v = isArray(d.value) ? d.value[0] : d.value;
+        if (v) {
+            if (v.startsWith && v.startsWith('bind:')) {
+                const watchExpression = $watch(v.replace('bind:', ''), scope, {}, variable.invokeOnParamChange.bind(variable, d), undefined, undefined, d, () => variable.isMuted);
+                v = scope.registerDestroyListener ? scope.registerDestroyListener(watchExpression) : watchExpression;
+            }
+            else if (!isUndefined(d.value)) {
+                setValueToNode$1(d.target, d, root, variable, d.value, true);
+                if (runMode && root !== targetNodeKey) {
+                    if (!internalBoundNodeMap$1.has(variable)) {
+                        internalBoundNodeMap$1.set(variable, {});
+                    }
+                    set(internalBoundNodeMap$1.get(variable), [variable.name, root, d.target], d.value);
+                }
+            }
+        }
+        return {
+            name: d.target,
+            value: v
+        };
+    }
+    processBinding(variable, context, bindSource, bindTarget) {
+        bindSource = bindSource || 'dataBinding';
+        bindTarget = bindTarget || 'dataBinding';
+        const bindMap = variable[bindSource];
+        variable[bindSource] = {};
+        variable['_bind' + bindSource] = bindMap;
+        if (!bindMap || !isArray(bindMap)) {
+            return;
+        }
+        bindMap.forEach((node) => {
+            /* for static variable change the binding with target 'dataBinding' to 'dataSet', as the results have to reflect directly in the dataSet */
+            if (variable.category === 'wm.Variable' && node.target === 'dataBinding') {
+                node.target = 'dataSet';
+            }
+            this.processBindExp(node, context, variable);
+        });
+    }
+    isVariableSeperated(variablesJson, variableName) {
+        return variablesJson[variableName].category === 'wm.Variable' || variablesJson[variableName].category === 'wm.ServiceVariable' ||
+            variablesJson[variableName].category === 'wm.LiveVariable' || variablesJson[variableName].category === 'wm.CrudVariable';
+    }
+    getBindSourceTarget(variable) {
+        if (variable.category === 'wm.LiveVariable') {
+            return variable.operation === 'read' ? 'filterFields' : 'inputFields';
+        }
+        else if (variable.category === 'wm.ModelVariable') {
+            return 'dataSet';
+        }
+        else {
+            return 'dataBinding';
+        }
+    }
+    /**
+     * Takes the raw variables and actions json as input
+     * Initialize the variable and action instances through the factory
+     * collect the variables and actions in separate maps and return the collection
+     * @param {string} page
+     * @param variablesJson
+     * @param scope
+     * @returns {Variables , Actions}
+     */
+    register(page, variablesJson, scope) {
+        const variableInstances = {
+            Variables: {},
+            Actions: {},
+            callback: this.triggerStartUpdate
+        };
+        let varInstance;
+        for (const variableName in variablesJson) {
+            const params = {};
+            varInstance = VariableFactory.create(variablesJson[variableName], scope);
+            varInstance.init();
+            if (this.isVariableSeperated(variablesJson, variableName)) {
+                this.processBinding(varInstance, scope, 'dataBinding', this.getBindSourceTarget(varInstance));
+                varInstance.httpService = this.httpService;
+                varInstance.dateFormatter = new Formatter();
+                // MEMORY LEAK FIX: Store subscription unsubscribe function (cleanup handled by registerDestroyListener)
+                const afterInvokeUnsubscribe = varInstance.subscribe('afterInvoke', () => $invokeWatchers(true));
+                // Store on variable for potential manual cleanup if needed
+                if (!varInstance._eventSubscriptions) {
+                    varInstance._eventSubscriptions = [];
+                }
+                varInstance._eventSubscriptions.push(afterInvokeUnsubscribe);
+                if (varInstance.category === 'wm.LiveVariable' && varInstance.operation === 'read') {
+                    processFilterExpBindNode(varInstance._context, varInstance.filterExpressions, varInstance);
+                }
+                if (varInstance.category === 'wm.CrudVariable' || varInstance.category === 'wm.ServiceVariable') {
+                    varInstance.simulateFileDownload = simulateFileDownload;
+                }
+            }
+            if (this.isVariableSeperated(variablesJson, variableName) || variablesJson[variableName].category === 'wm.TimerAction') {
+                for (const e in VARIABLE_CONSTANTS.EVENT) {
+                    if (varInstance[VARIABLE_CONSTANTS.EVENT[e]]) {
+                        varInstance[VARIABLE_CONSTANTS.EVENT[e]] = $parseEvent(varInstance[VARIABLE_CONSTANTS.EVENT[e]]);
+                    }
+                }
+            }
+            // if action type, put it in Actions namespace
+            if (varInstance instanceof BaseAction) {
+                variableInstances.Actions[variableName] = varInstance;
+            }
+            else {
+                variableInstances.Variables[variableName] = varInstance;
+            }
+        }
+        // if the context has onDestroy listener, subscribe the event and trigger cancel on all varibales
+        if (scope.registerDestroyListener) {
+            scope.registerDestroyListener(() => {
+                this.bulkCancel(variableInstances.Variables);
+                this.bulkCancel(variableInstances.Actions);
+            });
+        }
+        return variableInstances;
+    }
+    destroy() {
+    }
+    registerDependency(name, ref) {
+        setDependency(name, ref);
+        wmSetDependency(name, ref);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: VariablesService, deps: [{ token: i1.AbstractHttpService }, { token: MetadataService }, { token: i1.AbstractNavigationService }, { token: i3.Router }, { token: i1.AbstractToasterService }, { token: i4.OAuthService }, { token: i5.SecurityService }, { token: i1.AbstractDialogService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: VariablesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: VariablesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AbstractHttpService }, { type: MetadataService }, { type: i1.AbstractNavigationService }, { type: i3.Router }, { type: i1.AbstractToasterService }, { type: i4.OAuthService }, { type: i5.SecurityService }, { type: i1.AbstractDialogService }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { $rootScope, CONSTANTS, DB_CONSTANTS, Formatter, MODE_CONSTANTS, MetadataService, SWAGGER_CONSTANTS, VARIABLE_CONSTANTS, VARIABLE_URLS, VariableManagerFactory, VariablesService, WS_CONSTANTS, appManager, debounceVariableCall, dialogService, formatDate, formatExportExpression, getEvaluatedOrderBy, httpService, initiateCallback, isFileUploadSupported, metadataService, navigationService, oauthService, processBinding, routerService, securityService, setDependency, setInput, simulateFileDownload, toasterService };
+//# sourceMappingURL=index.mjs.map