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

package/variables/esm2022/util/variable/variables.utils.mjs

@@ -0,0 +1,809 @@
+import { $parseEvent, $watch, DataType, DEFAULT_FORMATS, extractType, findValueOf, getBlob, getClonedObject, stringStartsWith, triggerFn } from '@wm/core';
+import { VARIABLE_CONSTANTS, WS_CONSTANTS } from '../../constants/variables.constants';
+import { debounce, filter, forEach, get, includes, isArray, isDate, isEmpty, isFunction, isNumber, isObject, isString, isUndefined, join, keys, last, map, noop, pickBy, remove, replace, set, slice, split, toLower, toUpper, trim } from "lodash-es";
+import * as momentLib from 'moment';
+const moment = momentLib.default || window['moment'];
+const exportTypesMap = { 'EXCEL': '.xlsx', 'CSV': '.csv' };
+export let appManager;
+export let httpService;
+export let metadataService;
+export let navigationService;
+export let routerService;
+export let toasterService;
+export let oauthService;
+export let securityService;
+export 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;
+    }
+};
+export 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;
+    }
+};
+export 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
+ */
+export 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
+ */
+export 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}
+ */
+export 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}}
+ */
+export const isFileUploadSupported = () => {
+    return (window.File && window.FileReader && window.FileList && window.Blob);
+};
+/**
+ *
+ * @param varOrder
+ * @param optionsOrder
+ * @returns {any}
+ */
+export 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
+ */
+export const formatExportExpression = fieldDefs => {
+    forEach(fieldDefs, function (fieldDef) {
+        if (fieldDef.expression) {
+            fieldDef.expression = '${' + fieldDef.expression + '}';
+        }
+    });
+    return fieldDefs;
+};
+export 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
+export 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)
+ */
+export 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);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"variables.utils.js","sourceRoot":"","sources":["../../../../../projects/variables/src/util/variable/variables.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,MAAM,EACN,QAAQ,EACR,eAAe,EACf,WAAW,EACX,WAAW,EACX,OAAO,EACP,eAAe,EACf,gBAAgB,EAChB,SAAS,EACZ,MAAM,UAAU,CAAC;AAElB,OAAO,EAAY,kBAAkB,EAAE,YAAY,EAAC,MAAM,qCAAqC,CAAC;AAChG,OAAO,EACH,QAAQ,EAAE,MAAM,EAChB,OAAO,EACP,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAC9B,OAAO,EACP,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAC9B,QAAQ,EACR,WAAW,EACX,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EACrB,IAAI,EACJ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAC5B,KAAK,EACL,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAChC,MAAM,WAAW,CAAC;AAInB,OAAO,KAAK,SAAS,MAAO,QAAQ,CAAC;AACrC,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;AAGrD,MAAM,cAAc,GAAK,EAAE,OAAO,EAAG,OAAO,EAAE,KAAK,EAAG,MAAM,EAAC,CAAC;AAE9D,MAAM,CAAC,IAAI,UAAU,CAAC;AACtB,MAAM,CAAC,IAAI,WAAW,CAAC;AACvB,MAAM,CAAC,IAAI,eAAe,CAAC;AAC3B,MAAM,CAAC,IAAI,iBAAiB,CAAC;AAC7B,MAAM,CAAC,IAAI,aAAa,CAAC;AACzB,MAAM,CAAC,IAAI,cAAc,CAAC;AAC1B,MAAM,CAAC,IAAI,YAAY,CAAC;AACxB,MAAM,CAAC,IAAI,eAAe,CAAC;AAC3B,MAAM,CAAC,IAAI,aAAa,CAAC;AAEzB,MAAM,YAAY,GAAG,wBAAwB,EACzC,oBAAoB,GAAG,IAAI,GAAG,EAAE,EAChC,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;AAEvB,MAAM,OAAO,GAAG,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE;IAC7B,IAAI,WAAW,EACX,QAAQ,GAAG,IAAI,EACf,MAAM,CAAC;IACX,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QACvB,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC;IAC3C,CAAC;IACD,QAAQ,EAAE,CAAC;IACX,WAAW,GAAG,QAAQ,CAAC;QACnB,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;QACxB,8DAA8D;QAC9D,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC5B,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;IACL,CAAC,EAAE,GAAG,CAAC,CAAC;IACR,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAClC,WAAW,EAAE,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,6BAA6B,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;IACtF,QAAQ,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACxB,KAAK,kBAAkB,CAAC,QAAQ,CAAC,IAAI;YACjC,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;gBAChC,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;oBAC7B,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,EAAE,GAAG;wBAC/B,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG;4BACzB,OAAO,EAAE,GAAG;yBACf,CAAC;oBACN,CAAC,CAAC,CAAC;gBACP,CAAC;qBAAM,CAAC;oBACJ,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG;wBAC9B,OAAO,EAAE,OAAO;wBAChB,MAAM,EAAG,QAAQ;qBACpB,CAAC;gBACN,CAAC;gBACD,gFAAgF;gBAChF,IAAI,QAAQ,CAAC,UAAU,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChG,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;gBACrC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;oBAC7B,QAAQ,CAAC,WAAW,GAAG,OAAO,CAAC;gBACnC,CAAC;qBAAM,CAAC;oBACJ,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;gBAC7C,CAAC;gBACD,gFAAgF;gBAChF,IAAI,QAAQ,CAAC,UAAU,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACnH,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC;gBACrD,CAAC;YACL,CAAC;YACD,MAAM;QACV,KAAK,kBAAkB,CAAC,QAAQ,CAAC,IAAI;YACjC,IAAI,QAAQ,CAAC,aAAa,KAAK,MAAM,IAAI,QAAQ,CAAC,UAAU,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChI,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAChC,CAAC;YACD,MAAM;QACV,KAAK,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC;QACzC,KAAK,kBAAkB,CAAC,QAAQ,CAAC,KAAK;YAClC,IAAI,QAAQ,CAAC,UAAU,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC3F,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAChC,CAAC;YACD,MAAM;IACd,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAY,EAAE,GAAQ,EAAE,EAAE;IACpD,QAAQ,IAAI,EAAE,CAAC;QACX,KAAK,YAAY;YACb,UAAU,GAAG,GAAG,CAAC;YACjB,MAAM;QACV,KAAK,MAAM;YACP,WAAW,GAAG,GAAG,CAAC;YAClB,MAAM;QACV,KAAK,UAAU;YACX,eAAe,GAAG,GAAG,CAAC;YACtB,MAAM;QACV,KAAK,mBAAmB;YACpB,iBAAiB,GAAG,GAAG,CAAC;YACxB,MAAM;QACV,KAAK,QAAQ;YACT,aAAa,GAAG,GAAG,CAAC;YACpB,MAAM;QACV,KAAK,SAAS;YACV,cAAc,GAAI,GAAG,CAAC;YACtB,MAAM;QACV,KAAK,OAAO;YACR,YAAY,GAAI,GAAG,CAAC;YACpB,MAAM;QACV,KAAK,UAAU;YACX,eAAe,GAAI,GAAG,CAAC;YACvB,MAAM;QACV,KAAK,QAAQ;YACT,aAAa,GAAG,GAAG,CAAC;YACpB,MAAM;IACd,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAE,QAAa,EAAE,IAAS,EAAE,OAAa,EAAE,uBAAiC,EAAE,EAAE;IAEzH,gHAAgH;IAChH,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,EAC9B,aAAa,GAAG,QAAQ,CAAC,QAAQ,CAAC;IACtC,IAAI,aAAa,CAAC;IAClB;;;;OAIG;IACJ,IAAI,IAAI,KAAK,kBAAkB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACrE,IAAI,CAAC,WAAW,EAAE,CAAC;YACf,0FAA0F;YAC1F,aAAa,GAAG,aAAa,CAAC,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YACnF,IAAI,aAAa,EAAE,CAAC;gBAChB,IAAI,GAAG,aAAa,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC;gBAC1C,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,kDAAkD,CAAC;gBAClF,aAAa,CAAC,MAAM,CAAC,EAAE,SAAS,EAAG,IAAI,EAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;gBAC/D,sCAAsC;gBACnC,8HAA8H;gBAClI,MAAM;YACV,CAAC;QACL,CAAC;IACL,CAAC;IACD,iHAAiH;IACjH,MAAM,EAAE,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACvC,IAAI,IAAI,KAAK,kBAAkB,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAClD,IAAI,QAAQ,CAAC,QAAQ,KAAK,iBAAiB,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;YAC3E,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAC,CAAC,CAAC;QAC3F,CAAC;aAAM,CAAC;YACJ,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAC,CAAC,CAAC;QAC1F,CAAC;IACL,CAAC;SAAM,CAAC;QACJ,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAC,CAAC,CAAC;IACrF,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,EAAE;IACjC,UAAU,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACnD,CAAC,CAAC;AAEF,MAAM,wBAAwB,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;IACnE,uBAAuB;IACvB,IAAI,QAAQ,GAAG,EAAE,EACb,aAAa,EACb,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,WAAW,EACX,KAAK,CAAC;IACV,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IACvD,IAAI,WAAW,IAAI,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC1D,aAAa,GAAG,wCAAwC,CAAC;QACzD,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1C,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YACjC,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC/C,CAAC;IACL,CAAC;IAED,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACnC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAE5C,IAAI,OAAO,MAAM,CAAC,SAAS,CAAC,UAAU,KAAK,WAAW,EAAE,CAAC;QACrD,kMAAkM;QAClM,IAAI,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC9C,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACJ,SAAS,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;IACL,CAAC;SAAM,CAAC;QACJ,GAAG,GAAW,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC;QAC7C,WAAW,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAExC,IAAI,QAAQ,EAAE,CAAC;YACX,sDAAsD;YACtD,MAAM,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACtC,IAAI,MAAM,CAAC;YACX,kCAAkC;YAClC,IAAI,OAAO,CAAC,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;gBACpC,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC1B,MAAM,CAAC,SAAS,GAAG;oBACf,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;oBAC3E,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;oBACnC,IAAI,CAAC,KAAK,EAAE,CAAC;wBACT,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAC;oBAC/B,CAAC;gBACL,CAAC,CAAC;gBACF,MAAM,CAAC,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAC1D,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;gBACvB,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACJ,CAAC,CAAC,IAAI,GAAG,WAAW,CAAC;gBACrB,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC;gBACtB,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7B,CAAC,CAAC,KAAK,EAAE,CAAC;gBACV,gBAAgB,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;YAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;gBACT,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,WAAW,CAAC;YACvC,CAAC;YACD,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;QAED,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,UAAU;IAC5E,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,UAAU,GAAG,CAAC,WAAW,EAAE,EAAE;IAC/B,IAAI,CAAC,WAAW,EAAE,CAAC;QACf,OAAO;IACX,CAAC;IACD,OAAO,WAAW,CAAC;IACnB,sCAAsC;IACtC;;;;;;;;;;;QAWI;AACR,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,gBAAgB,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE;IAC7C,WAAW,GAAG,KAAK,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IACtC,OAAO,CAAC,WAAW,EAAE,UAAU,KAAK;QAChC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC1B,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,qBAAqB,GAAG,CAAC,aAAa,EAAE,OAAO,EAAE,WAAW,EAAC,KAAK,EAAE,EAAE;IACxE,gGAAgG;IAChG,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;QAC/D,aAAa,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,aAAa,EACb,MAAM,EACN,YAAY,EACZ,WAAW,GAAG,EAAE,EAChB,IAAI,CAAC;IACT,MAAM,WAAW,GAAO,oBAAoB,EACxC,SAAS,GAAS,kBAAkB,EACpC,YAAY,GAAM,cAAc,EAChC,GAAG,GAAe,aAAa,CAAC,GAAG,EACnC,OAAO,GAAG,GAAG,CAAC,aAAa,CAAC,OAAO,EAAE,YAAY,CAAC,EAClD,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,EAAE,GAAG;QACrD,OAAO,GAAG,KAAK,YAAY,CAAC;IAChC,CAAC,CAAC,CAAC;IACP;oDACgD;IAEhD,0DAA0D;IAC1D,aAAa,GAAG,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,CAAC;IACrC,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;QACvB,aAAa,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC;IACnC,CAAC;IACD,aAAa,GAAG,CAAC,CAAC,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,6BAA6B,CAAC,CAAC;IAC3G,MAAM,GAAU,CAAC,CAAC,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC,CAAC;IAEnF,wFAAwF;IACxF,WAAW,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAClF,WAAW,IAAI,OAAO,KAAK,YAAY,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEpI,MAAM,CAAC,IAAI,CAAC;QACR,QAAQ,EAAI,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC;QACtC,QAAQ,EAAI,GAAG;QACf,QAAQ,EAAI,aAAa,CAAC,MAAM;QAChC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,kBAAkB;KAC9H,CAAC,CAAC;IAEH,wEAAwE;IACxE,IAAI,QAAQ,CAAC,YAAY,CAAC,qBAAqB,EAAE,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QAC9E,gBAAgB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,kCAAkC;IAC7E,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/B,gBAAgB,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA,8BAA8B;QAC3E,IAAI,GAAG,MAAM,CAAC;IAClB,CAAC;SAAM,CAAC;QACJ,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC;IACvD,CAAC;IACD,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,EAAE,GAAG;QAC5B,YAAY,GAAG,CAAC,CAAC,uBAAuB,CAAC,CAAC;QAC1C,YAAY,CAAC,IAAI,CAAC;YACd,MAAM,EAAI,GAAG;YACb,OAAO,EAAG,GAAG;SAChB,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAChC,CAAC,CAAC,CAAC;IAEH,0EAA0E;IAC1E,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAEhC,gFAAgF;IAChF,UAAU,CAAC;QACP,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE;YACrB,IAAI,SAAS;gBAAE,OAAO;YACtB,MAAM,IAAI,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;YAC1D,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;gBACtB,SAAS,GAAG,IAAI,CAAC;gBACjB,IAAI,OAAO,CAAC;gBACZ,IAAI,CAAC;oBACD,OAAO,GAAE,EAAC,KAAK,EAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAC,CAAE;gBAC9C,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACV,OAAO,GAAC,EAAE,CAAA;gBACb,CAAC;gBACD,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC9B,CAAC;QACL,CAAC,CAAC,CAAC;QACH,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrD,MAAM,CAAC,MAAM,EAAE,CAAC;QAChB,UAAU,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,SAAS,EAAE,CAAC;gBACb,SAAS,GAAG,IAAI,CAAC;gBACjB,SAAS,CAAC,OAAO,CAAC,CAAC;YACvB,CAAC;QACL,CAAC,EAAE,IAAI,CAAC,CAAC;IACb,CAAC,EAAE,GAAG,CAAC,CAAC;AACZ,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;IACrD,MAAM,GAAG,GAAO,MAAM,CAAC,GAAG,EACtB,MAAM,GAAI,MAAM,CAAC,MAAM,EACvB,IAAI,GAAM,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,IAAI,EAC1C,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,mCAAmC,CAAC;IAEzF,qCAAqC;IACrC,WAAW,CAAC,IAAI,CAAC;QACb,QAAQ,EAAG,YAAY;QACvB,QAAQ,EAAG,uBAAuB;QAClC,QAAQ,EAAG,MAAM;QACjB,KAAK,EAAM,GAAG;QACd,SAAS,EAAE,OAAO;QAClB,MAAM,EAAK,IAAI;QACf,cAAc,EAAE,aAAa;KAChC,CAAC,CAAC,IAAI,CAAC,UAAU,QAAQ;QACtB,UAAU,CAAC,GAAG,EAAE;YACZ,wBAAwB,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QAC9E,CAAC,EAAE,GAAG,CAAC,CAAC;IACZ,CAAC,EAAE,UAAU,GAAG;QACZ,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE;IACnD,IAAI,aAAa,CAAC;IAClB,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEpC,IAAI,YAAY,EAAE,CAAC;QACf,aAAa,GAAG,cAAc,CAAC,YAAY,CAAC,CAAC;IACjD,CAAC;SAAM,CAAC;QACJ,aAAa,GAAG,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;QACjD,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,QAAQ,GAAG,GAAG,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAC7D,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,EAAE;IAC7B,2CAA2C;IAC3C,OAAO,QAAQ,CAAC;AACpB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,aAAa,GAAG,GAAG,EAAE;IACvB,OAAO,KAAK,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACzC;;;;;;;;;;;OAWG;IACH,IAAI,MAAM,GAAG,GAAG,CAAC,MAAM,EACnB,SAAS,CAAC;IACd,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,SAAS,GAAG,QAAQ,CAAC;IACzB,CAAC;SAAM,CAAC;QACJ,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;QACnD,IAAI,GAAG,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACtB,SAAS,GAAG,QAAQ,CAAC;QACzB,CAAC;aAAM,IAAI,MAAM,EAAE,CAAC;YAChB,SAAS,GAAG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACJ,SAAS,GAAG,QAAQ,CAAC;QACzB,CAAC;IACL,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,EAAE;IAChC;;;;;;;;;;;OAWG;IACH,IAAI,aAAa,CAAC;IAClB,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,sBAAsB,EAAE,EAAE,CAAC,CAAC;IAC/D,CAAC;SAAM,CAAC;QACJ,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,aAAa,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAS,EAAE,EAAE;IACrE,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,EAC1C,SAAS,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAClD,KAAK,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC;IAChD,oGAAoG;IACpG,IAAI,SAAS,EAAE,CAAC;QACZ,SAAS,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC;IACrC,CAAC;IACD,6BAA6B,CAAC,aAAa,EAAE,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACtF,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACnD,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAC3F,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,aAAa,CAAC;IAClB,SAAS,qBAAqB;QAC1B,OAAO,MAAM,CAAC,kBAAkB,EAAE,UAAU,IAAI;YAC5C,oJAAoJ;YACpJ,OAAO,CAAC,IAAI,KAAK,aAAa,IAAI,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,KAAK,IAAI,IAAI,aAAa,KAAK,aAAa,CAAC,IAAI,IAAI,KAAK,aAAa,CAAC,CAAC;QAChK,CAAC,CAAC,CAAC;IACP,CAAC;IACD,aAAa,GAAG,qBAAqB,EAAE,CAAC;IACxC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QACzB,OAAO,CAAC,aAAa,EAAE,UAAU,IAAI;YACjC,cAAc,CAAC,IAAI,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAC/H,CAAC,CAAC,CAAC;IACP,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACrD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,EACrB,SAAS,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,EAC7C,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,EACxC,OAAO,GAAG,IAAI,CAAC;IACnB,MAAM,SAAS,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEnG,IAAI,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;QACvC,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE;YAChC,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1I,OAAO;YACX,CAAC;YACD,+BAA+B;YAC/B,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;YACrC,CAAC;YACD,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,0CAA0C;YAE/F,IAAI,OAAO,EAAE,CAAC;gBACV,iEAAiE;gBACjE,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACtC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;gBAC3C,CAAC;gBACD,GAAG,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;gBAC/E,4DAA4D;gBAC5D,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBACnB,mBAAmB,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;gBAChD,CAAC;YACL,CAAC;QACL,CAAC,CAAC;QACF,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IACpI,CAAC;SAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC7D,IAAI,OAAO,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;YACpC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACtC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC3C,CAAC;YACD,GAAG,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QACtF,CAAC;IACL,CAAC;AACL,CAAC,CAAC;AAEF,oIAAoI;AAEpI;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,QAAa,EAAE,OAAY,EAAE,UAAmB,EAAE,UAAmB,EAAE,EAAE;IACpG,UAAU,GAAG,UAAU,IAAI,aAAa,CAAC;IACzC,UAAU,GAAG,UAAU,IAAI,aAAa,CAAC;IAEzC,MAAM,OAAO,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;IAC1B,QAAQ,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,OAAO,CAAC;IACzC,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,OAAO;IACX,CAAC;IACD,OAAO,CAAC,OAAO,CAAC,UAAU,IAAI;QAC1B,2IAA2I;QAC3I,IAAI,QAAQ,CAAC,QAAQ,KAAK,aAAa,IAAI,IAAI,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;YACvE,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC5B,CAAC;QACD,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE;IACvG;sEACkE;IAClE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,aAAa,EAAE,EAAE,CAAC;QACrD,qBAAqB,CAAC,aAAa,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACzD,CAAC;SAAM,CAAC;QACJ,qBAAqB,CAAC,aAAa,EAAE,OAAO,EAAE,WAAW,EAAC,KAAK,CAAC,CAAC;IACrE,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,SAAc,EAAE,GAAQ,EAAE,GAAQ,EAAE,OAAY,EAAE,EAAE;IACzE,SAAS,GAAG,SAAS,IAAI,EAAE,CAAC;IAC5B,IAAI,IAAI,EACJ,OAAO,EACP,QAAQ,GAAG,EAAE,CAAC;IAElB,qBAAqB;IACrB,IAAI,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,aAAa;QACb,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,MAAM;gBACP,aAAa;gBACb,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;gBACxC,MAAM;YACV,KAAK,QAAQ;gBACT,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAC9C,MAAM;QACd,CAAC;IACL,CAAC;IAED,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAChB,oDAAoD;QACpD,QAAQ,GAAG,GAAG,CAAC;IACnB,CAAC;SAAM,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QAC/B,kDAAkD;QAClD,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtB,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACrB,sCAAsC;QACtC,SAAS,GAAG,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;QACzD,GAAG,GAAG,OAAO,CAAC;QACd,QAAQ,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IACxB,CAAC;SAAM,CAAC;QACJ,QAAQ,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IACxB,CAAC;IAED,OAAO,CAAC,QAAQ,EAAE,UAAU,QAAQ,EAAE,QAAQ;QAC1C,SAAS,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;IACnC,CAAC,CAAC,CAAC;IACH,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,EAAE;IACtC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;AAChF,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE;IAC1D,IAAI,YAAY,EACZ,UAAU,CAAC;IACf,4DAA4D;IAC5D,IAAI,CAAC,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACzC,OAAO,QAAQ,CAAC;IACpB,CAAC;IACD,4DAA4D;IAC5D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACZ,OAAO,YAAY,CAAC;IACxB,CAAC;IACD,sGAAsG;IACtG,QAAQ,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAChC,YAAY,GAAG,KAAK,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IACxC,YAAY,GAAG,GAAG,CAAC,YAAY,EAAE,UAAU,KAAK;QAC5C,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IACH,kFAAkF;IAClF,MAAM,CAAC,QAAQ,EAAE,UAAU,OAAe;QACtC,OAAO,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IACH,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9D,OAAO,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,GAAG,UAAU,CAAC;AAChD,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,SAAS,CAAC,EAAE;IAC9C,OAAO,CAAC,SAAS,EAAE,UAAU,QAAQ;QACjC,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YACtB,QAAQ,CAAC,UAAU,GAAG,IAAI,GAAG,QAAQ,CAAC,UAAU,GAAG,GAAG,CAAC;QAC3D,CAAC;IACL,CAAC,CAAC,CAAC;IACH,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,OAAO,CAAC;AAE5C,MAAM,wBAAwB,GAAG,CAAC,IAAI,EAAE,EAAE;IACtC,OAAO,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AAC1C,CAAC,CAAC;AAEF,kCAAkC;AAClC,MAAM,WAAW,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE;IACpC,IAAI,KAAK,CAAC;IACV,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QACpB,KAAK,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;SAAM,CAAC;QACJ,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YACpB,SAAS,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACxC,CAAC;QACD,KAAK,GAAG,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IACrD,CAAC;IACD,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,QAAQ,CAAC,IAAI,EAAE,CAAC;QACzC,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,IAAI,IAAI,KAAK,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,IAAI,IAAI,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QACnC,KAAK,GAAG,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,YAAY,EAAE,GAAG,GAAG,GAAG,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IAC1E,CAAC;IACD,OAAO,SAAS,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC;AACpG,CAAC,CAAC;AAEF,qEAAqE;AACrE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;IACtC,IAAI,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;QACtB,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC,CAAC;IACD,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG;YAC3B,OAAO,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;IACP,CAAC;IACD,OAAO,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,eAAe,EAAE,EAAE;IAC1C,IAAI,CAAC,eAAe,EAAE,CAAC;QACnB,OAAO,eAAe,CAAC;IAC3B,CAAC;IACD,IAAI,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,EAAE;YAC5B,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjB,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC;iBAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxB,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;oBACzB,IAAI,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;wBAC3B,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;oBAClC,CAAC;yBAAM,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;wBACzB,UAAU,CAAC,KAAK,CAAC,CAAC;oBACtB,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;SAAM,IAAI,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;QACnC,OAAO,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACpC,IAAI,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3B,eAAe,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;YAC7C,CAAC;iBAAM,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,UAAU,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;SAAM,IAAI,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;QACnC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC;QAC9C,OAAO,eAAe,CAAC;IAC3B,CAAC;AACL,CAAC,CAAC;AAEF,SAAS,UAAU,CAAC,KAAK;IACrB,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC","sourcesContent":["import {\n    $parseEvent,\n    $watch,\n    DataType,\n    DEFAULT_FORMATS,\n    extractType,\n    findValueOf,\n    getBlob,\n    getClonedObject,\n    stringStartsWith,\n    triggerFn\n} from '@wm/core';\n\nimport {CONSTANTS, VARIABLE_CONSTANTS, WS_CONSTANTS} from '../../constants/variables.constants';\nimport {\n    debounce, filter,\n    forEach,\n    get, includes, isArray, isDate,\n    isEmpty,\n    isFunction, isNumber, isObject,\n    isString,\n    isUndefined,\n    join, keys, last, map,\n    noop,\n    pickBy, remove, replace, set,\n    slice,\n    split, toLower, toUpper, trim\n} from \"lodash-es\";\n\ndeclare const $;\ndeclare const he;\nimport * as momentLib  from 'moment';\nconst moment = momentLib.default || window['moment'];\ndeclare const window;\n\nconst exportTypesMap   = { 'EXCEL' : '.xlsx', 'CSV' : '.csv'};\n\nexport let appManager;\nexport let httpService;\nexport let metadataService;\nexport let navigationService;\nexport let routerService;\nexport let toasterService;\nexport let oauthService;\nexport let securityService;\nexport let dialogService;\n\nconst DOT_EXPR_REX = /^\\[(\"|')[\\w\\W]*(\\1)\\]$/,\n    internalBoundNodeMap = new Map(),\n    timers = new Map();\n\nconst _invoke = (variable, op) => {\n    let debouncedFn,\n        cancelFn = noop,\n        retVal;\n    if (timers.has(variable)) {\n        cancelFn = timers.get(variable).cancel;\n    }\n    cancelFn();\n    debouncedFn = debounce(function () {\n        retVal = variable[op]();\n        // handle promises to avoid uncaught promise errors in console\n        if (retVal instanceof Promise) {\n            retVal.catch(noop);\n        }\n    }, 100);\n    timers.set(variable, debouncedFn);\n    debouncedFn();\n};\n\nconst processVariablePostBindUpdate = (nodeName, nodeVal, nodeType, variable, noUpdate) => {\n    switch (variable.category) {\n        case VARIABLE_CONSTANTS.CATEGORY.LIVE:\n            if (variable.operation === 'read') {\n                if (nodeName === 'dataBinding') {\n                    forEach(nodeVal, function (val, key) {\n                        variable.filterFields[key] = {\n                            'value': val\n                        };\n                    });\n                } else {\n                    variable.filterFields[nodeName] = {\n                        'value': nodeVal,\n                        'type' : nodeType\n                    };\n                }\n                /* if auto-update set for the variable with read operation only, get its data */\n                if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.listRecords) && !noUpdate) {\n                    _invoke(variable, 'listRecords');\n                }\n            } else {\n                if (nodeName === 'dataBinding') {\n                    variable.inputFields = nodeVal;\n                } else {\n                    variable.inputFields[nodeName] = nodeVal;\n                }\n                /* if auto-update set for the variable with read operation only, get its data */\n                if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable[variable.operation + 'Record']) && !noUpdate) {\n                    _invoke(variable, variable.operation + 'Record');\n                }\n            }\n            break;\n        case VARIABLE_CONSTANTS.CATEGORY.CRUD:\n            if (variable.operationType === 'list' && variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.invoke) && !noUpdate) {\n                _invoke(variable, 'invoke');\n            }\n            break;\n        case VARIABLE_CONSTANTS.CATEGORY.SERVICE:\n        case VARIABLE_CONSTANTS.CATEGORY.LOGIN:\n            if (variable.autoUpdate && !isUndefined(nodeVal) && isFunction(variable.invoke) && !noUpdate) {\n                _invoke(variable, 'invoke');\n            }\n            break;\n    }\n};\n\nexport const setDependency = (type: string, ref: any) => {\n    switch (type) {\n        case 'appManager':\n            appManager = ref;\n            break;\n        case 'http':\n            httpService = ref;\n            break;\n        case 'metadata':\n            metadataService = ref;\n            break;\n        case 'navigationService':\n            navigationService = ref;\n            break;\n        case 'router':\n            routerService = ref;\n            break;\n        case 'toaster':\n            toasterService =  ref;\n            break;\n        case 'oAuth':\n            oauthService =  ref;\n            break;\n        case 'security':\n            securityService =  ref;\n            break;\n        case 'dialog':\n            dialogService = ref;\n            break;\n    }\n};\n\nexport const initiateCallback = (type: string, variable: any, data: any, options?: any, skipDefaultNotification?: boolean) => {\n\n    /*checking if event is available and variable has event property and variable event property bound to function*/\n    const eventValues = variable[type],\n        callBackScope = variable._context;\n    let errorVariable;\n    /**\n     * For error event:\n     * trigger app level error handler.\n     * if no event is assigned, trigger default appNotification variable.\n     */\n   if (type === VARIABLE_CONSTANTS.EVENT.ERROR && !skipDefaultNotification) {\n        if (!eventValues) {\n            /* in case of error, if no event assigned, handle through default notification variable */\n            errorVariable = callBackScope.Actions[VARIABLE_CONSTANTS.DEFAULT_VAR.NOTIFICATION];\n            if (errorVariable) {\n                data = errorVariable.getMessage() || data;\n                data = isString(data) ? data : 'An error has occured. Please check the app logs.';\n                errorVariable.invoke({ 'message' : data}, undefined, undefined);\n                 // $rootScope.$evalAsync(function () {\n                    // $rootScope.$emit(\"invoke-service\", VARIABLE_CONSTANTS.DEFAULT_VAR.NOTIFICATION, {scope: callBackScope, message: response});\n                // });\n            }\n        }\n    }\n    // TODO: [Vibhu], check whether to support legacy event calling mechanism (ideally, it should have been migrated)\n    const fn = $parseEvent(variable[type]);\n    if (type === VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE) {\n        if (variable.category === 'wm.LiveVariable' && variable.operation === 'read') {\n            return fn(variable._context, {variable: variable, dataFilter: data, options: options});\n        } else {\n            return fn(variable._context, {variable: variable, inputData: data, options: options});\n        }\n    } else {\n        return fn(variable._context, {variable: variable, data: data, options: options});\n    }\n};\n\nconst triggerOnTimeout = (success) => {\n    setTimeout(() => { triggerFn(success); }, 500);\n};\n\nconst downloadFilefromResponse = (response, headers, success, error) => {\n    // check for a filename\n    let filename = '',\n        filenameRegex,\n        matches,\n        type,\n        blob,\n        URL,\n        downloadUrl,\n        popup;\n    const disposition = headers.get('Content-Disposition');\n    if (disposition && disposition.indexOf('attachment') !== -1) {\n        filenameRegex = /filename[^;=\\n]*=((['\"]).*?\\2|[^;\\n]*)/;\n        matches = filenameRegex.exec(disposition);\n        if (matches !== null && matches[1]) {\n            filename = matches[1].replace(/['\"]/g, '');\n        }\n    }\n\n    type = headers.get('Content-Type');\n    blob = new Blob([response], { type: type });\n\n    if (typeof window.navigator.msSaveBlob !== 'undefined') {\n        // 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.\"\n        if (window.navigator.msSaveBlob(blob, filename)) {\n            triggerOnTimeout(success);\n        } else {\n            triggerFn(error);\n        }\n    } else {\n        URL         = window.URL || window.webkitURL;\n        downloadUrl = URL.createObjectURL(blob);\n\n        if (filename) {\n            // use HTML5 a[download] attribute to specify filename\n            const a = document.createElement('a');\n            let reader;\n            // safari doesn't support this yet\n            if (typeof a.download === 'undefined') {\n                reader = new FileReader();\n                reader.onloadend = function () {\n                    const url = reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');\n                    popup = window.open(url, '_blank');\n                    if (!popup) {\n                        window.location.href = url;\n                    }\n                };\n                reader.onload = triggerOnTimeout.bind(undefined, success);\n                reader.onerror = error;\n                reader.readAsDataURL(blob);\n            } else {\n                a.href = downloadUrl;\n                a.download = filename;\n                document.body.appendChild(a);\n                a.click();\n                triggerOnTimeout(success);\n            }\n        } else {\n            popup = window.open(downloadUrl, '_blank');\n            if (!popup) {\n                window.location.href = downloadUrl;\n            }\n            triggerOnTimeout(success);\n        }\n\n        setTimeout(() => { URL.revokeObjectURL(downloadUrl); }, 100); // cleanup\n    }\n};\n\nconst getService = (serviceName) => {\n    if (!serviceName) {\n        return;\n    }\n    return serviceName;\n    // Todo: Shubham, uncomment below code\n    /* /!* get a reference to the element where ng-app is defined *!/\n     let appEl = WM.element('[id=ng-app]'), injector;\n     if (appEl) {\n     try {\n     injector = appEl.injector(); // get the angular injector\n     if (injector) {\n     return injector.get(serviceName); // return the service\n     }\n     } catch (e) {\n     return undefined;\n     }\n     }*/\n};\n\n/**\n * Construct the form data params from the URL\n * @param queryParams\n * @param params\n */\nconst setParamsFromURL = (queryParams, params) => {\n    queryParams = split(queryParams, '&');\n    forEach(queryParams, function (param) {\n        param = split(param, '=');\n        params[param[0]] = decodeURIComponent(join(slice(param, 1), '='));\n    });\n};\n\n/**\n * [Todo: Shubham], Implement Download through I frame\n * Simulates file download in an app through creating and submitting a hidden form in DOM.\n * The action will be initiated through a Service Variable\n *\n * Query Params\n * The request params like query params are added as hidden input elements\n *\n * Header Params\n * The header params for a request are also added along with hidden input elements.\n * This is done as headers can not be set for a form POST call from JavaScript\n *\n * Finally, request parameters are sent as follows:\n * For a GET request, the request data is sent along with the query params.\n * For POST, it is sent as request body.\n *\n * @param variable: the variable that is called from user action\n * @param requestParams object consisting the info to construct the XHR request for the service\n */\nconst downloadThroughIframe = (requestParams, success, dataBinding,error) => {\n    // Todo: SHubham: URL contains '//' in between which should be handled at the URL formation only\n    if (requestParams.url[1] === '/' && requestParams.url[2] === '/') {\n        requestParams.url = requestParams.url.slice(0, 1) + requestParams.url.slice(2);\n    }\n    let iFrameElement,\n        formEl,\n        paramElement,\n        queryParams = '',\n        data;\n    const IFRAME_NAME     = 'fileDownloadIFrame',\n        FORM_NAME       = 'fileDownloadForm',\n        CONTENT_TYPE    = 'Content-Type',\n        url             = requestParams.url,\n        encType = get(requestParams.headers, CONTENT_TYPE),\n        params = pickBy(requestParams.headers, function (val, key) {\n            return key !== CONTENT_TYPE;\n        });\n    /* Todo: shubham : define getService method\n     WS_CONSTANTS    = getService('WS_CONSTANTS');*/\n\n    /* look for existing iframe. If exists, remove it first */\n    iFrameElement = $('#' + IFRAME_NAME);\n    if (iFrameElement.length) {\n        iFrameElement.first().remove();\n    }\n    iFrameElement = $('<iframe id=\"' + IFRAME_NAME + '\" name=\"' + IFRAME_NAME + '\" class=\"ng-hide\"></iframe>');\n    formEl        = $('<form id=\"' + FORM_NAME + '\" name=\"' + FORM_NAME + '\"></form>');\n\n    /* process query params, append a hidden input element in the form against each param */\n    queryParams += url.indexOf('?') !== -1 ? url.substring(url.indexOf('?') + 1) : '';\n    queryParams += encType === WS_CONSTANTS.CONTENT_TYPES.FORM_URL_ENCODED ? ((queryParams ? '&' : '') + requestParams.dataParams) : '';\n\n    formEl.attr({\n        'target'  : iFrameElement.attr('name'),\n        'action'  : url,\n        'method'  : requestParams.method,\n        'enctype': !(isEmpty(requestParams.data) && isEmpty(queryParams)) ? encType : WS_CONSTANTS.CONTENT_TYPES.MULTIPART_FORMDATA\n    });\n\n    // For Non body methods only, set the input fields from query parameters\n    if (includes(WS_CONSTANTS.NON_BODY_HTTP_METHODS, toUpper(requestParams.method))) {\n        setParamsFromURL(queryParams, params); // Set params for URL query params\n    }\n    if (!isEmpty(requestParams.data)) {\n        setParamsFromURL(requestParams.data, params);// Set params for request data\n        data = params;\n    } else {\n        data = isEmpty(dataBinding) ? params : dataBinding;\n    }\n    forEach(data, function (val, key) {\n        paramElement = $('<input type=\"hidden\">');\n        paramElement.attr({\n            'name'  : key,\n            'value' : val\n        });\n        formEl.append(paramElement);\n    });\n\n    /* append form to iFrame and iFrame to the document and submit the form */\n    $('body').append(iFrameElement);\n\n    // timeout for IE 10, iframeElement.contents() is empty in IE 10 without timeout\n    setTimeout(function () {\n        let completed = false;\n        iFrameElement.on(\"load\", function () {\n            if (completed) return;\n            const text = iFrameElement.contents().find('body').text();\n            if (text && text.trim()) {\n                completed = true;\n                let message;\n                try {\n                    message ={error:JSON.parse(text.trim())} ;\n                } catch (e) {\n                   message=\"\"\n                }\n                triggerFn(error, message);\n            }\n        });\n        iFrameElement.contents().find('body').append(formEl);\n        formEl.submit();\n        setTimeout(() => {\n            if (!completed) {\n                completed = true;\n                triggerFn(success);\n            }\n        }, 2000);\n    }, 100);\n};\n\n/**\n * Makes an XHR call against the config\n * the response is converted into a blob url, which is assigned to the src attribute of an anchor element with download=true\n * a click is simulated on the anchor to download the file\n * @param config\n * @param success\n * @param error\n */\nconst downloadThroughAnchor = (config, success, error) => {\n    const url     = config.url,\n        method  = config.method,\n        data    = config.dataParams || config.data,\n        headers = config.headers;\n\n    headers['Content-Type'] = headers['Content-Type'] || 'application/x-www-form-urlencoded';\n\n    // Todo: Replace http with getService\n    httpService.send({\n        'target' : 'WebService',\n        'action' : 'invokeRuntimeRestCall',\n        'method' : method,\n        'url'    : url,\n        'headers': headers,\n        'data'   : data,\n        'responseType': 'arraybuffer'\n    }).then(function (response) {\n        setTimeout(() => {\n            downloadFilefromResponse(response.body, response.headers, success, error);\n        }, 900);\n    }, function (err) {\n        triggerFn(error, err);\n    });\n};\n\n/**\n * appends a timestamp on the passed filename to prevent caching\n * returns the modified file name\n * @param fileName\n * @param exportFormat\n * @returns {string}\n */\nconst getModifiedFileName = (fileName, exportFormat) => {\n    let fileExtension;\n    const currentTimestamp = Date.now();\n\n    if (exportFormat) {\n        fileExtension = exportTypesMap[exportFormat];\n    } else {\n        fileExtension = '.' + last(split(fileName, '.'));\n        fileName = replace(fileName, fileExtension, '');\n    }\n    return fileName + '_' + currentTimestamp + fileExtension;\n};\n\nconst getCookieByName = (name) => {\n    // Todo: Shubham Implement cookie native js\n    return 'cookie';\n};\n\n/**\n * This function returns the cookieValue if xsrf is enabled.\n * In device, xsrf cookie is stored in localStorage.\n * @returns xsrf cookie value\n */\nconst isXsrfEnabled = () => {\n    return false;\n};\n\n/**\n * Returns the object node for a bind object, where the value has to be updated\n * obj.target = \"a\"\n * @param obj\n * @param root\n * @param variable\n * @returns {*}\n */\nconst getTargetObj = (obj, root, variable) => {\n    /*\n     * if the target key is in the form as \"['my.param']\"\n     * keep the target key as \"my.param\" and do not split further\n     * this is done, so that, the computed value against this binding is assigned as\n     *      {\"my.param\": \"value\"}\n     * and not as\n     *      {\n     *          \"my\": {\n     *              \"param\": \"value\"\n     *          }\n     *      }\n     */\n    let target = obj.target,\n        targetObj;\n    const rootNode = variable[root];\n    if (DOT_EXPR_REX.test(target)) {\n        targetObj = rootNode;\n    } else {\n        target = target.substr(0, target.lastIndexOf('.'));\n        if (obj.target === root) {\n            targetObj = variable;\n        } else if (target) {\n            targetObj = findValueOf(rootNode, target, true);\n        } else {\n            targetObj = rootNode;\n        }\n    }\n    return targetObj;\n};\n\n/**\n * Gets the key for the target object\n * the computed value will be updated against this key in the targetObject(computed by getTargetObj())\n * @param target\n * @param regex\n * @returns {*}\n */\nconst getTargetNodeKey = (target) => {\n    /*\n     * if the target key is in the form as \"['my.param']\"\n     * keep the target key as \"my.param\" and do not split further\n     * this is done, so that, the computed value against this binding is assigned as\n     *      {\"my.param\": \"value\"}\n     * and not as\n     *      {\n     *          \"my\": {\n     *              \"param\": \"value\"\n     *          }\n     *      }\n     */\n    let targetNodeKey;\n    if (DOT_EXPR_REX.test(target)) {\n        targetNodeKey = target.replace(/^(\\[[\"'])|([\"']\\])$/g, '');\n    } else {\n        targetNodeKey = target.split('.').pop();\n    }\n    return targetNodeKey;\n};\n\nconst setValueToNode = (target, obj, root, variable, value, noUpdate?) => {\n    const targetNodeKey = getTargetNodeKey(target),\n        targetObj = getTargetObj(obj, root, variable);\n    value = !isUndefined(value) ? value : obj.value;\n    /* sanity check, user can bind parent nodes to non-object values, so child node bindings may fail */\n    if (targetObj) {\n        targetObj[targetNodeKey] = value;\n    }\n    processVariablePostBindUpdate(targetNodeKey, value, obj.type, variable, noUpdate);\n};\n\n/**\n * The model internalBoundNodeMap stores the reference to latest computed values against internal(nested) bound nodes\n * 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\n * E.g.\n * Variable.employeeVar has following bindings\n * \"dataBinding\": [\n     {\n         \"target\": \"department.budget\",\n         \"value\": \"bind:Variables.budgetVar.dataSet\"\n     },\n     {\n         \"target\": \"department\",\n         \"value\": \"bind:Variables.departmentVar.dataSet\"\n     }\n ]\n * When department.budget is computed, employeeVar.dataSet = {\n *  \"department\": {\n *      \"budget\": {\"q1\": 1111}\n *  }\n * }\n *\n * When department is computed\n *  \"department\": {\n *      \"name\": \"HR\",\n *      \"location\": \"Hyderabad\"\n *  }\n * The budget field (computed earlier) is LOST.\n *\n * To avoid this, the latest values against internal nodes (in this case department.budget) are stored in a map\n * These values are assigned back to internal fields if the parent is computed (in this case department)\n * @param target\n * @param root\n * @param variable\n */\nconst updateInternalNodes = (target, root, variable) => {\n    const boundInternalNodes = keys(get(internalBoundNodeMap.get(variable), [variable.name, root])),\n        targetNodeKey = getTargetNodeKey(target);\n    let internalNodes;\n    function findInternalNodeBound() {\n        return filter(boundInternalNodes, function (node) {\n            // the later condition in check (targetNodeKey === root || targetNodeKey === 'dataBinding') is specifically for live variable of insert/update types\n            return (node !== targetNodeKey && includes(node, targetNodeKey)) || ((targetNodeKey === root || targetNodeKey === 'dataBinding') && node !== targetNodeKey);\n        });\n    }\n    internalNodes = findInternalNodeBound();\n    if ((internalNodes.length)) {\n        forEach(internalNodes, function (node) {\n            setValueToNode(node, {target: node}, root, variable, get(internalBoundNodeMap.get(variable), [variable.name, root, node]));\n        });\n    }\n};\n\n/**\n * New Implementation (DataBinding Flat Structure with x-path targets)\n * processes a dataBinding object, if bound to expression, watches over it, else assigns value to the expression\n * @param obj dataBinding object\n * @param scope scope of the variable\n * @param root root node string (dataBinding for all variables, dataSet for static variable)\n * @param variable variable object\n */\nconst processBindObject = (obj, scope, root, variable) => {\n    const target = obj.target,\n        targetObj = getTargetObj(obj, root, variable),\n        targetNodeKey = getTargetNodeKey(target),\n        runMode = true;\n    const destroyFn = scope.registerDestroyListener ? scope.registerDestroyListener.bind(scope) : noop;\n\n    if (stringStartsWith(obj.value, 'bind:')) {\n        const listener = (newVal, oldVal) => {\n            if ((newVal === oldVal && isUndefined(newVal)) || (isUndefined(newVal) && (!isUndefined(oldVal) || !isUndefined(targetObj[targetNodeKey])))) {\n                return;\n            }\n            // Skip cloning for blob column\n            if (!includes(['blob', 'file'], obj.type)) {\n                newVal = getClonedObject(newVal);\n            }\n            setValueToNode(target, obj, root, variable, newVal); // cloning newVal to keep the source clean\n\n            if (runMode) {\n                /*set the internal bound node map with the latest updated value*/\n                if (!internalBoundNodeMap.has(variable)) {\n                    internalBoundNodeMap.set(variable, {});\n                }\n                set(internalBoundNodeMap.get(variable), [variable.name, root, target], newVal);\n                /*update the internal nodes after internal node map is set*/\n                if (isObject(newVal)) {\n                    updateInternalNodes(target, root, variable);\n                }\n            }\n        };\n        destroyFn($watch(obj.value.replace('bind:', ''), scope, {}, listener, undefined, undefined, undefined, () => variable.isMuted));\n    } else if (!isUndefined(obj.value)) {\n        setValueToNode(target, obj, root, variable, obj.value, true);\n        if (runMode && root !== targetNodeKey) {\n            if (!internalBoundNodeMap.has(variable)) {\n                internalBoundNodeMap.set(variable, {});\n            }\n            set(internalBoundNodeMap.get(variable), [variable.name, root, target], obj.value);\n        }\n    }\n};\n\n// *********************************************************** PUBLIC *********************************************************** //\n\n/**\n * Initializes watchers for binding expressions configured in the variable\n * @param variable\n * @param context, scope context in which the variable exists\n * @param {string} bindSource,  the field in variable where the databindings are configured\n *                              for most variables, it will be 'dataBinding', hence default fallback is to 'dataBinding'\n *                              for some it can be 'dataSet' and hence will be passed as param\n * @param {string} bindTarget, the object field in variable where the computed bindings will be set\n */\nexport const processBinding = (variable: any, context: any, bindSource?: string, bindTarget?: string) => {\n    bindSource = bindSource || 'dataBinding';\n    bindTarget = bindTarget || 'dataBinding';\n\n    const bindMap = variable[bindSource];\n    variable[bindSource] = {};\n    variable['_bind' + bindSource] = bindMap;\n    if (!bindMap || !isArray(bindMap)) {\n        return;\n    }\n    bindMap.forEach(function (node) {\n        /* for static variable change the binding with target 'dataBinding' to 'dataSet', as the results have to reflect directly in the dataSet */\n        if (variable.category === 'wm.Variable' && node.target === 'dataBinding') {\n            node.target = 'dataSet';\n        }\n        processBindObject(node, context, bindTarget, variable);\n    });\n};\n\n/**\n * Downloads a file in the browser.\n * Two methods to do so, namely:\n * 1. downloadThroughAnchor, called if\n *      - if a header is to be passed\n *      OR\n *      - if security is ON and XSRF token is to be sent as well\n * NOTE: This method does not work with Safari version 10.0 and below\n *\n * 2. downloadThroughIframe\n *      - this method works across browsers and uses an iframe to downlad the file.\n * @param requestParams request params object\n * @param fileName represents the file name\n * @param exportFormat downloaded file format\n * @param success success callback\n * @param error error callback\n */\nexport const simulateFileDownload = (requestParams, fileName, exportFormat, success, error, dataBinding) => {\n    /*success and error callbacks are executed incase of downloadThroughAnchor\n     Due to technical limitation cannot be executed incase of iframe*/\n    if (!isEmpty(requestParams.headers) || isXsrfEnabled()) {\n        downloadThroughAnchor(requestParams, success, error);\n    } else {\n        downloadThroughIframe(requestParams, success, dataBinding,error);\n    }\n};\n\n/**\n * sets the value against passed key on the \"inputFields\" object in the variable\n * @param targetObj: the object in which the key, value is to be set\n * @param variable\n * @param key: can be:\n *  - a string e.g. \"username\"\n *  - an object, e.g. {\"username\": \"john\", \"ssn\": \"11111\"}\n * @param val\n * - if key is string, the value against it (for that data type)\n * - if key is object, not required\n * @param options\n * @returns {any}\n */\nexport const setInput = (targetObj: any, key: any, val: any, options: any) => {\n    targetObj = targetObj || {};\n    let keys,\n        lastKey,\n        paramObj = {};\n\n    // content type check\n    if (isObject(options)) {\n        // @ts-ignore\n        switch (options.type) {\n            case 'file':\n                // @ts-ignore\n                val = getBlob(val, options.contentType);\n                break;\n            case 'number':\n                val = isNumber(val) ? val : parseInt(val, 10);\n                break;\n        }\n    }\n\n    if (isObject(key)) {\n        // check if the passed parameter is an object itself\n        paramObj = key;\n    } else if (key.indexOf('.') > -1) {\n        // check for '.' in key e.g. 'employee.department'\n        keys = key.split('.');\n        lastKey = keys.pop();\n        // Finding the object based on the key\n        targetObj = findValueOf(targetObj, keys.join('.'), true);\n        key = lastKey;\n        paramObj[key] = val;\n    } else {\n        paramObj[key] = val;\n    }\n\n    forEach(paramObj, function (paramVal, paramKey) {\n        targetObj[paramKey] = paramVal;\n    });\n    return targetObj;\n};\n\n/**\n * returns true if HTML5 File API is available else false\n * @returns {{prototype: Blob; new(blobParts?: any[], options?: BlobPropertyBag): Blob}}\n */\nexport const isFileUploadSupported = () => {\n    return (window.File && window.FileReader && window.FileList && window.Blob);\n};\n\n/**\n *\n * @param varOrder\n * @param optionsOrder\n * @returns {any}\n */\nexport const getEvaluatedOrderBy = (varOrder, optionsOrder) => {\n    let optionFields,\n        varOrderBy;\n    // If options order by is not defined, return variable order\n    if (!optionsOrder || isEmpty(optionsOrder)) {\n        return varOrder;\n    }\n    // If variable order by is not defined, return options order\n    if (!varOrder) {\n        return optionsOrder;\n    }\n    // If both are present, combine the options order and variable order, with options order as precedence\n    varOrder = split(varOrder, ',');\n    optionsOrder = split(optionsOrder, ',');\n    optionFields = map(optionsOrder, function (order) {\n        return split(trim(order), ' ')[0];\n    });\n    // If a field is present in both options and variable, remove the variable orderby\n    remove(varOrder, function (orderBy: string) {\n        return includes(optionFields, split(trim(orderBy), ' ')[0]);\n    });\n    varOrderBy = varOrder.length ? ',' + join(varOrder, ',') : '';\n    return join(optionsOrder, ',') + varOrderBy;\n};\n\n/**\n * formatting the expression as required by backend which was enclosed by ${<expression>}.\n * @param fieldDefs\n * returns fieldDefs\n */\nexport const formatExportExpression = fieldDefs => {\n    forEach(fieldDefs, function (fieldDef) {\n        if (fieldDef.expression) {\n            fieldDef.expression = '${' + fieldDef.expression + '}';\n        }\n    });\n    return fieldDefs;\n};\n\nexport const debounceVariableCall = _invoke;\n\nconst getDateTimeFormatForType = (type) => {\n    return DEFAULT_FORMATS[toUpper(type)];\n};\n\n// Format value for datetime types\nconst _formatDate = (dateValue, type) => {\n    let epoch;\n    if (isDate(dateValue)) {\n        epoch = dateValue.getTime();\n    } else {\n        if (!isNaN(dateValue)) {\n            dateValue = parseInt(dateValue, 10);\n        }\n        epoch = dateValue && moment(dateValue).valueOf();\n    }\n    if (isNaN(epoch) && type !== DataType.TIME) {\n        return epoch;\n    }\n    if (type === DataType.TIMESTAMP) {\n        return epoch;\n    }\n    if (type === DataType.TIME && !epoch) {\n        epoch = moment(new Date().toDateString() + ' ' + dateValue).valueOf();\n    }\n    return dateValue && appManager.getPipe('date').transform(epoch, getDateTimeFormatForType(type));\n};\n\n// Function to convert values of date time types into default formats\nexport const formatDate = (value, type) => {\n    if (includes(type, '.')) {\n        type = toLower(extractType(type));\n    }\n    if (isArray(value)) {\n        return map(value, function (val) {\n            return _formatDate(val, type);\n        });\n    }\n    return _formatDate(value, type);\n};\n\n/**\n * This method decodes the variable data which is encoded from backend before showing in the widgets.\n * It takes variable response content as input and iterates recursively,\n * if the value is string type then it will decode the data.\n * @param responseContent (Array of objects)\n */\nexport const decodeData = (responseContent) => {\n    if (!responseContent) {\n        return responseContent;\n    }\n    if (isArray(responseContent)) {\n        forEach(responseContent, data => {\n            if (isString(data)) {\n                data = htmlDecode(data);\n            } else if (isObject(data)) {\n                forEach(data, (value, key) => {\n                    if (value && isString(value)) {\n                        data[key] = htmlDecode(value);\n                    } else if (isObject(value)) {\n                        decodeData(value);\n                    }\n                });\n            }\n        });\n    } else if (isObject(responseContent)) {\n        forEach(responseContent, (value, key) => {\n            if (value && isString(value)) {\n                responseContent[key] = htmlDecode(value);\n            } else if (isObject(value)) {\n                decodeData(value);\n            }\n        });\n    } else if (isString(responseContent)) {\n        responseContent = htmlDecode(responseContent);\n        return responseContent;\n    }\n};\n\nfunction htmlDecode(input) {\n    return he.unescape(input);\n}\n"]}