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

package/variables/esm2022/service/metadata-service/metadata.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import { _WM_APP_PROJECT, AbstractHttpService } from '@wm/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+export 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 }] });
+//# sourceMappingURL=data:application/json;base64,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

package/variables/esm2022/service/variables.service.mjs

@@ -0,0 +1,199 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { $invokeWatchers, $parseEvent, $watch, AbstractDialogService, AbstractHttpService, AbstractNavigationService, AbstractToasterService, processFilterExpBindNode } from '@wm/core';
+import { OAuthService } from '@wm/oAuth';
+import { SecurityService } from '@wm/security';
+import { VariableFactory } from '../factory/variable.factory';
+import { BaseAction, getTarget, getTargetNodeKey, internalBoundNodeMap, setValueToNode, wmSetDependency } from '@wavemaker-ai/variables';
+import { appManager, setDependency, simulateFileDownload } from '../util/variable/variables.utils';
+import { MetadataService } from './metadata-service/metadata.service';
+import { VARIABLE_CONSTANTS } from '../constants/variables.constants';
+import { isArray, isFunction, isUndefined, set } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+import * as i2 from "./metadata-service/metadata.service";
+import * as i3 from "@angular/router";
+import * as i4 from "@wm/oAuth";
+import * as i5 from "@wm/security";
+export class Formatter {
+    format(value, format) {
+        return appManager.getPipe('date').transform(value, format);
+    }
+}
+export 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(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(d.target, d, root, variable, d.value, true);
+                if (runMode && root !== targetNodeKey) {
+                    if (!internalBoundNodeMap.has(variable)) {
+                        internalBoundNodeMap.set(variable, {});
+                    }
+                    set(internalBoundNodeMap.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: i2.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: i2.MetadataService }, { type: i1.AbstractNavigationService }, { type: i3.Router }, { type: i1.AbstractToasterService }, { type: i4.OAuthService }, { type: i5.SecurityService }, { type: i1.AbstractDialogService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"variables.service.js","sourceRoot":"","sources":["../../../../projects/variables/src/service/variables.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Router} from '@angular/router';\n\nimport {\n    $invokeWatchers,\n    $parseEvent,\n    $watch,\n    AbstractDialogService,\n    AbstractHttpService,\n    AbstractNavigationService,\n    AbstractToasterService,\n    processFilterExpBindNode\n} from '@wm/core';\nimport {OAuthService} from '@wm/oAuth';\nimport {SecurityService} from '@wm/security';\n\nimport {VariableFactory} from '../factory/variable.factory';\nimport {\n    BaseAction,\n    DateFormatter,\n    getTarget,\n    getTargetNodeKey,\n    internalBoundNodeMap,\n    setValueToNode,\n    wmSetDependency\n} from '@wavemaker-ai/variables';\nimport {appManager, setDependency, simulateFileDownload} from '../util/variable/variables.utils';\nimport {MetadataService} from './metadata-service/metadata.service';\nimport {VARIABLE_CONSTANTS} from '../constants/variables.constants';\nimport {isArray, isFunction, isUndefined, set} from \"lodash-es\";\n\nexport class Formatter implements DateFormatter {\n    format(value, format) {\n        return  appManager.getPipe('date').transform(value, format);\n    }\n}\n\n\n@Injectable()\nexport class VariablesService {\n\n    constructor(\n        private httpService: AbstractHttpService,\n        private metadataService: MetadataService,\n        private navigationService: AbstractNavigationService,\n        private routerService: Router,\n        private toasterService: AbstractToasterService,\n        private oAuthService: OAuthService,\n        private securityService: SecurityService,\n        private dialogService: AbstractDialogService\n    ) {\n        // set external dependencies, to be used across variable classes, managers and utils\n        setDependency('http', this.httpService);\n        setDependency('metadata', this.metadataService);\n        setDependency('navigationService', this.navigationService);\n        setDependency('router', this.routerService);\n        setDependency('toaster', this.toasterService);\n        setDependency('oAuth', this.oAuthService);\n        setDependency('security', this.securityService);\n        setDependency('dialog', this.dialogService);\n        wmSetDependency('oAuth', this.oAuthService);\n        wmSetDependency('security', this.securityService);\n        wmSetDependency('metadata', this.metadataService);\n        wmSetDependency('http', this.httpService);\n    }\n\n    /**\n     * loop through a collection of variables/actions\n     * trigger cancel on each (of exists)\n     * @param collection\n     */\n    bulkCancel(collection) {\n        Object.keys(collection).forEach(name => {\n            const variable = collection[name];\n            if (isFunction(variable.cancel)) {\n                variable.cancel();\n            }\n        });\n    }\n\n    /**\n     * loops over the variable/actions collection and trigger invoke on it if startUpdate on it is true\n     * @param collection\n     */\n    triggerStartUpdate(collection) {\n        return Promise.all(\n            Object.keys(collection)\n                .map(name => collection[name])\n                .filter( variable => variable?.startUpdate && variable.invoke)\n                .map(variable => variable.invoke())\n            );\n    }\n\n    processBindExp(d: any, scope: any, variable) {\n        const root = getTarget(variable),\n            targetNodeKey = getTargetNodeKey(d.target),\n            runMode = true;\n        let v = isArray(d.value) ? d.value[0] : d.value;\n        if (v) {\n            if (v.startsWith && v.startsWith('bind:')) {\n                const watchExpression = $watch(v.replace('bind:', ''), scope, {}, variable.invokeOnParamChange.bind(variable, d), undefined, undefined, d, () => variable.isMuted);\n                v = scope.registerDestroyListener ? scope.registerDestroyListener(watchExpression) : watchExpression;\n            } else if (!isUndefined(d.value)) {\n                setValueToNode(d.target, d, root, variable, d.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, d.target], d.value);\n                }\n            }\n        }\n        return {\n            name: d.target,\n            value: v\n        };\n    }\n\n    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( (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            this.processBindExp(node, context, variable);\n        });\n    }\n\n    isVariableSeperated(variablesJson, variableName) {\n        return variablesJson[variableName].category === 'wm.Variable' || variablesJson[variableName].category === 'wm.ServiceVariable' ||\n            variablesJson[variableName].category === 'wm.LiveVariable' || variablesJson[variableName].category === 'wm.CrudVariable'\n    }\n\n    getBindSourceTarget(variable) {\n        if (variable.category === 'wm.LiveVariable') {\n            return variable.operation === 'read' ? 'filterFields' : 'inputFields';\n        } else if (variable.category === 'wm.ModelVariable') {\n            return 'dataSet';\n        } else {\n            return 'dataBinding';\n        }\n    }\n\n    /**\n     * Takes the raw variables and actions json as input\n     * Initialize the variable and action instances through the factory\n     * collect the variables and actions in separate maps and return the collection\n     * @param {string} page\n     * @param variablesJson\n     * @param scope\n     * @returns {Variables , Actions}\n     */\n    register(page: string, variablesJson: any, scope: any) {\n        const variableInstances = {\n            Variables: {},\n            Actions: {},\n            callback: this.triggerStartUpdate\n        };\n        let varInstance;\n\n        for (const variableName in variablesJson) {\n            const params: any = {};\n            varInstance = VariableFactory.create(variablesJson[variableName], scope);\n            varInstance.init();\n           if (this.isVariableSeperated(variablesJson, variableName)) {\n               this.processBinding(varInstance, scope, 'dataBinding', this.getBindSourceTarget(varInstance));\n               varInstance.httpService = this.httpService;\n               varInstance.dateFormatter = new Formatter();\n               // MEMORY LEAK FIX: Store subscription unsubscribe function (cleanup handled by registerDestroyListener)\n               const afterInvokeUnsubscribe = varInstance.subscribe('afterInvoke', () => $invokeWatchers(true));\n               // Store on variable for potential manual cleanup if needed\n               if (!varInstance._eventSubscriptions) {\n                   varInstance._eventSubscriptions = [];\n               }\n               varInstance._eventSubscriptions.push(afterInvokeUnsubscribe);\n               if (varInstance.category === 'wm.LiveVariable' && varInstance.operation === 'read') {\n                   processFilterExpBindNode(varInstance._context, varInstance.filterExpressions, varInstance);\n               }\n               if (varInstance.category === 'wm.CrudVariable' || varInstance.category === 'wm.ServiceVariable') {\n                   varInstance.simulateFileDownload = simulateFileDownload;\n               }\n\n           }\n\n           if (this.isVariableSeperated(variablesJson, variableName) || variablesJson[variableName].category === 'wm.TimerAction') {\n               for (const e in VARIABLE_CONSTANTS.EVENT) {\n                   if (varInstance[VARIABLE_CONSTANTS.EVENT[e]]) {\n                       varInstance[VARIABLE_CONSTANTS.EVENT[e]] = $parseEvent(varInstance[VARIABLE_CONSTANTS.EVENT[e]]);\n                   }\n               }\n           }\n\n\n            // if action type, put it in Actions namespace\n            if (varInstance instanceof BaseAction) {\n                variableInstances.Actions[variableName] = varInstance;\n            } else {\n                variableInstances.Variables[variableName] = varInstance;\n            }\n        }\n\n        // if the context has onDestroy listener, subscribe the event and trigger cancel on all varibales\n        if (scope.registerDestroyListener) {\n            scope.registerDestroyListener(() => {\n                this.bulkCancel(variableInstances.Variables);\n                this.bulkCancel(variableInstances.Actions);\n            });\n        }\n\n        return variableInstances;\n    }\n\n    destroy() {\n    }\n\n    registerDependency(name, ref) {\n        setDependency(name, ref);\n        wmSetDependency(name, ref);\n    }\n}\n"]}

package/variables/esm2022/util/action/navigation-action.utils.mjs

@@ -0,0 +1,52 @@
+import { navigationService } from '../variable/variables.utils';
+import { clone, isNil, isString } from "lodash-es";
+/**
+ * Handles variable navigation operations
+ * @param variable
+ * @param options
+ */
+export 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);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1hY3Rpb24udXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YXJpYWJsZXMvc3JjL3V0aWwvYWN0aW9uL25hdmlnYXRpb24tYWN0aW9uLnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBQyxNQUFNLFdBQVcsQ0FBQztBQUVqRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLENBQUMsUUFBUSxFQUFFLE9BQU8sRUFBRSxFQUFFO0lBQzFDLFFBQVEsQ0FBQyxPQUFPLEdBQUcsQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLFFBQVEsQ0FBQyxPQUFPLENBQUM7SUFDakUsSUFBSSxRQUFRLENBQUM7SUFDYixNQUFNLFFBQVEsR0FBRyxRQUFRLENBQUMsV0FBVyxDQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsUUFBUSxFQUMvRCxTQUFTLEdBQUcsUUFBUSxDQUFDLFNBQVMsRUFDOUIsU0FBUyxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEVBQ25DLFNBQVMsR0FBRyxLQUFLLENBQUMsT0FBTyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDO0lBQ25GLE9BQU8sR0FBRyxPQUFPLElBQUksRUFBRSxDQUFDO0lBRXhCLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsSUFBSSxTQUFTLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FBQztRQUN6RSxTQUFTLENBQUMsYUFBYSxDQUFDLEdBQUcsU0FBUyxDQUFDO0lBQ3pDLENBQUM7SUFFRCx3REFBd0Q7SUFDeEQsUUFBUSxTQUFTLEVBQUUsQ0FBQztRQUNoQixLQUFLLGtCQUFrQjtZQUNuQixpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNqQyxNQUFNO1FBQ1YsS0FBSyxVQUFVO1lBQ1gsaUJBQWlCLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRTtnQkFDakMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxlQUFlO2dCQUNwQyxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07Z0JBQ3RCLFNBQVMsRUFBRSxTQUFTO2dCQUNwQixTQUFTLEVBQUUsUUFBUSxDQUFDLFNBQVM7YUFDaEMsQ0FBQyxDQUFDO1lBQ0gsTUFBTTtRQUNWLEtBQUssVUFBVTtZQUNYLFFBQVEsR0FBRyxDQUFDLFFBQVEsQ0FBQyxXQUFXLElBQUksUUFBUSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsSUFBSSxRQUFRLENBQUMsUUFBUSxDQUFDO1lBQ3hGLE1BQU07UUFDVixLQUFLLFNBQVM7WUFDVixRQUFRLEdBQUcsQ0FBQyxRQUFRLENBQUMsV0FBVyxJQUFJLFFBQVEsQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLElBQUksUUFBUSxDQUFDLE9BQU8sQ0FBQztZQUN0RixNQUFNO1FBQ1YsS0FBSyxlQUFlO1lBQ2hCLFFBQVEsR0FBRyxDQUFDLFFBQVEsQ0FBQyxXQUFXLElBQUksUUFBUSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsSUFBSSxRQUFRLENBQUMsYUFBYSxDQUFDO1lBQ2xHLE1BQU07UUFDVixLQUFLLGFBQWE7WUFDZCxRQUFRLEdBQUcsQ0FBQyxRQUFRLENBQUMsV0FBVyxJQUFJLFFBQVEsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLElBQUksUUFBUSxDQUFDLFdBQVcsQ0FBQztZQUM5RixNQUFNO0lBQ2QsQ0FBQztJQUVELHdEQUF3RDtJQUN4RCxJQUFJLFFBQVEsRUFBRSxDQUFDO1FBQ1gsaUJBQWlCLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRTtZQUNqQyxRQUFRLEVBQUUsUUFBUTtZQUNsQixVQUFVLEVBQUUsUUFBUSxDQUFDLGVBQWU7WUFDcEMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNO1lBQ3RCLFNBQVMsRUFBRSxTQUFTO1NBQ3ZCLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDakIsQ0FBQztBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG5hdmlnYXRpb25TZXJ2aWNlIH0gZnJvbSAnLi4vdmFyaWFibGUvdmFyaWFibGVzLnV0aWxzJztcbmltcG9ydCB7Y2xvbmUsIGlzTmlsLCBpc1N0cmluZ30gZnJvbSBcImxvZGFzaC1lc1wiO1xuXG4vKipcbiAqIEhhbmRsZXMgdmFyaWFibGUgbmF2aWdhdGlvbiBvcGVyYXRpb25zXG4gKiBAcGFyYW0gdmFyaWFibGVcbiAqIEBwYXJhbSBvcHRpb25zXG4gKi9cbmV4cG9ydCBjb25zdCBuYXZpZ2F0ZSA9ICh2YXJpYWJsZSwgb3B0aW9ucykgPT4ge1xuICAgIHZhcmlhYmxlLmRhdGFTZXQgPSAob3B0aW9ucyAmJiBvcHRpb25zLmRhdGEpIHx8IHZhcmlhYmxlLmRhdGFTZXQ7XG4gICAgbGV0IHZpZXdOYW1lO1xuICAgIGNvbnN0IHBhZ2VOYW1lID0gdmFyaWFibGUuZGF0YUJpbmRpbmcucGFnZU5hbWUgfHwgdmFyaWFibGUucGFnZU5hbWUsXG4gICAgICAgIG9wZXJhdGlvbiA9IHZhcmlhYmxlLm9wZXJhdGlvbixcbiAgICAgICAgdXJsUGFyYW1zID0gY2xvbmUodmFyaWFibGUuZGF0YVNldCksXG4gICAgICAgIGNhY2hlYWJsZSA9IGlzTmlsKG9wdGlvbnM/LmNhY2hlYWJsZSkgPyB2YXJpYWJsZS5jYWNoZWFibGUgOiBvcHRpb25zLmNhY2hlYWJsZTtcbiAgICBvcHRpb25zID0gb3B0aW9ucyB8fCB7fTtcblxuICAgIGlmICghaXNOaWwoY2FjaGVhYmxlKSAmJiAoIWlzU3RyaW5nKGNhY2hlYWJsZSkgfHwgY2FjaGVhYmxlLnRyaW0oKSAhPT0gJycpKSB7XG4gICAgICAgIHVybFBhcmFtc1snX2NhY2hlX3BhZ2UnXSA9IGNhY2hlYWJsZTtcbiAgICB9XG5cbiAgICAvKiBpZiBvcGVyYXRpb24gaXMgZ29Ub1BhZ2UsIG5hdmlnYXRlIHRvIHRoZSBwYWdlTmFtZSAqL1xuICAgIHN3aXRjaCAob3BlcmF0aW9uKSB7XG4gICAgICAgIGNhc2UgJ2dvVG9QcmV2aW91c1BhZ2UnOlxuICAgICAgICAgICAgbmF2aWdhdGlvblNlcnZpY2UuZ29Ub1ByZXZpb3VzKCk7XG4gICAgICAgICAgICBicmVhaztcbiAgICAgICAgY2FzZSAnZ290b1BhZ2UnOlxuICAgICAgICAgICAgbmF2aWdhdGlvblNlcnZpY2UuZ29Ub1BhZ2UocGFnZU5hbWUsIHtcbiAgICAgICAgICAgICAgICB0cmFuc2l0aW9uOiB2YXJpYWJsZS5wYWdlVHJhbnNpdGlvbnMsXG4gICAgICAgICAgICAgICAgJGV2ZW50OiBvcHRpb25zLiRldmVudCxcbiAgICAgICAgICAgICAgICB1cmxQYXJhbXM6IHVybFBhcmFtcyxcbiAgICAgICAgICAgICAgICBjYWNoZWFibGU6IHZhcmlhYmxlLmNhY2hlYWJsZVxuICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICBicmVhaztcbiAgICAgICAgY2FzZSAnZ290b1ZpZXcnOlxuICAgICAgICAgICAgdmlld05hbWUgPSAodmFyaWFibGUuZGF0YUJpbmRpbmcgJiYgdmFyaWFibGUuZGF0YUJpbmRpbmcudmlld05hbWUpIHx8IHZhcmlhYmxlLnZpZXdOYW1lO1xuICAgICAgICAgICAgYnJlYWs7XG4gICAgICAgIGNhc2UgJ2dvdG9UYWInOlxuICAgICAgICAgICAgdmlld05hbWUgPSAodmFyaWFibGUuZGF0YUJpbmRpbmcgJiYgdmFyaWFibGUuZGF0YUJpbmRpbmcudGFiTmFtZSkgfHwgdmFyaWFibGUudGFiTmFtZTtcbiAgICAgICAgICAgIGJyZWFrO1xuICAgICAgICBjYXNlICdnb3RvQWNjb3JkaW9uJzpcbiAgICAgICAgICAgIHZpZXdOYW1lID0gKHZhcmlhYmxlLmRhdGFCaW5kaW5nICYmIHZhcmlhYmxlLmRhdGFCaW5kaW5nLmFjY29yZGlvbk5hbWUpIHx8IHZhcmlhYmxlLmFjY29yZGlvbk5hbWU7XG4gICAgICAgICAgICBicmVhaztcbiAgICAgICAgY2FzZSAnZ290b1NlZ21lbnQnOlxuICAgICAgICAgICAgdmlld05hbWUgPSAodmFyaWFibGUuZGF0YUJpbmRpbmcgJiYgdmFyaWFibGUuZGF0YUJpbmRpbmcuc2VnbWVudE5hbWUpIHx8IHZhcmlhYmxlLnNlZ21lbnROYW1lO1xuICAgICAgICAgICAgYnJlYWs7XG4gICAgfVxuXG4gICAgLyogaWYgdmlldyBuYW1lIGZvdW5kLCBjYWxsIHJvdXRpbmUgdG8gbmF2aWdhdGUgdG8gaXQgKi9cbiAgICBpZiAodmlld05hbWUpIHtcbiAgICAgICAgbmF2aWdhdGlvblNlcnZpY2UuZ29Ub1ZpZXcodmlld05hbWUsIHtcbiAgICAgICAgICAgIHBhZ2VOYW1lOiBwYWdlTmFtZSxcbiAgICAgICAgICAgIHRyYW5zaXRpb246IHZhcmlhYmxlLnBhZ2VUcmFuc2l0aW9ucyxcbiAgICAgICAgICAgICRldmVudDogb3B0aW9ucy4kZXZlbnQsXG4gICAgICAgICAgICB1cmxQYXJhbXM6IHVybFBhcmFtc1xuICAgICAgICB9LCB2YXJpYWJsZSk7XG4gICAgfVxufTtcbiJdfQ==

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

@@ -0,0 +1,11 @@
+import { oauthService, appManager } from './variable/variables.utils';
+export const performAuthorization = (url, providerId, onSuccess, onError, securityObj) => {
+    oauthService.perfromOAuthorization(url, providerId, onSuccess, onError, securityObj, appManager.getCustomUrlScheme(), appManager.getDeployedURL());
+};
+export const getAccessToken = (provider, checkLoaclStorage) => {
+    return oauthService.getAccessToken(provider, checkLoaclStorage);
+};
+export const removeAccessToken = (provider) => {
+    oauthService.removeAccessToken(provider);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib0F1dGgudXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy92YXJpYWJsZXMvc3JjL3V0aWwvb0F1dGgudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV0RSxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLEdBQVEsRUFBRSxVQUFlLEVBQUUsU0FBYyxFQUFFLE9BQVksRUFBRSxXQUFpQixFQUFFLEVBQUU7SUFDL0csWUFBWSxDQUFDLHFCQUFxQixDQUFDLEdBQUcsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsVUFBVSxDQUFDLGtCQUFrQixFQUFFLEVBQUUsVUFBVSxDQUFDLGNBQWMsRUFBRSxDQUFDLENBQUM7QUFDdkosQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsUUFBYSxFQUFFLGlCQUFzQixFQUFFLEVBQUU7SUFDcEUsT0FBTyxZQUFZLENBQUMsY0FBYyxDQUFDLFFBQVEsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO0FBQ3BFLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQUMsUUFBYSxFQUFFLEVBQUU7SUFDL0MsWUFBWSxDQUFDLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQzdDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG9hdXRoU2VydmljZSwgYXBwTWFuYWdlciB9IGZyb20gJy4vdmFyaWFibGUvdmFyaWFibGVzLnV0aWxzJztcblxuZXhwb3J0IGNvbnN0IHBlcmZvcm1BdXRob3JpemF0aW9uID0gKHVybDogYW55LCBwcm92aWRlcklkOiBhbnksIG9uU3VjY2VzczogYW55LCBvbkVycm9yOiBhbnksIHNlY3VyaXR5T2JqPzogYW55KSA9PiB7XG4gICAgb2F1dGhTZXJ2aWNlLnBlcmZyb21PQXV0aG9yaXphdGlvbih1cmwsIHByb3ZpZGVySWQsIG9uU3VjY2Vzcywgb25FcnJvciwgc2VjdXJpdHlPYmosIGFwcE1hbmFnZXIuZ2V0Q3VzdG9tVXJsU2NoZW1lKCksIGFwcE1hbmFnZXIuZ2V0RGVwbG95ZWRVUkwoKSk7XG59O1xuXG5leHBvcnQgY29uc3QgZ2V0QWNjZXNzVG9rZW4gPSAocHJvdmlkZXI6IGFueSwgY2hlY2tMb2FjbFN0b3JhZ2U6IGFueSkgPT4ge1xuICAgIHJldHVybiBvYXV0aFNlcnZpY2UuZ2V0QWNjZXNzVG9rZW4ocHJvdmlkZXIsIGNoZWNrTG9hY2xTdG9yYWdlKTtcbn07XG5cbmV4cG9ydCBjb25zdCByZW1vdmVBY2Nlc3NUb2tlbiA9IChwcm92aWRlcjogYW55KSA9PiB7XG4gICAgb2F1dGhTZXJ2aWNlLnJlbW92ZUFjY2Vzc1Rva2VuKHByb3ZpZGVyKTtcbn1cbiJdfQ==