dry-ux 1.37.0 → 1.39.0

package/dist/dajaxice/DajaxiceCall.d.ts

@@ -0,0 +1,21 @@
+import { IDajaxiceProxy, MethodArgs } from "./Proxy.interface";
+export declare class DajaxiceCall<TModule, TReturn> {
+    readonly module: string;
+    readonly method: string;
+    readonly config: IDajaxiceProxy<TModule>;
+    readonly methodArgs: MethodArgs;
+    private readonly loader?;
+    private readonly deferred;
+    private readonly cacheId;
+    private readonly defaultCacheDuration;
+    constructor(module: string, method: string, config: IDajaxiceProxy<TModule>, methodArgs: MethodArgs);
+    execute(): Promise<TReturn>;
+    private hideLoader;
+    private showLoader;
+    private handleError;
+    private handleApiCallSuccess;
+    private handleResult;
+    private callApi;
+    private checkCache;
+    private storeCache;
+}

package/dist/dajaxice/DajaxiceCall.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DajaxiceCall = void 0;
+const utilities_1 = require("../helpers/utilities");
+const Loader_1 = require("../ui-utils/Loader");
+class DajaxiceCall {
+    constructor(module, method, config, methodArgs) {
+        this.module = module;
+        this.method = method;
+        this.config = config;
+        this.methodArgs = methodArgs;
+        this.deferred = new utilities_1.Deferred();
+        this.defaultCacheDuration = 15;
+        this.hideLoader = () => {
+            var _a;
+            try {
+                (_a = this.loader) === null || _a === void 0 ? void 0 : _a.hide();
+            }
+            catch (e) { }
+        };
+        this.showLoader = () => {
+            var _a;
+            try {
+                (_a = this.loader) === null || _a === void 0 ? void 0 : _a.show();
+            }
+            catch (e) { }
+        };
+        this.handleError = (e) => {
+            var _a, _b, _c;
+            try {
+                !((_a = this.methodArgs.skip) === null || _a === void 0 ? void 0 : _a.errorHandler) && ((_c = (_b = this.config).onError) === null || _c === void 0 ? void 0 : _c.call(_b, e));
+            }
+            catch (e) { }
+            this.hideLoader();
+            this.deferred.reject(e);
+        };
+        this.handleApiCallSuccess = (result) => {
+            this.handleResult(result);
+            const { cache = false } = this.methodArgs;
+            if (cache) {
+                this.storeCache(result);
+            }
+        };
+        this.handleResult = (result) => {
+            this.hideLoader();
+            this.deferred.resolve(result);
+        };
+        this.callApi = () => {
+            const api = window["Dajaxice"][this.module][this.method];
+            const { args, cache = false } = this.methodArgs;
+            if (cache) {
+                const { exists, data } = this.checkCache();
+                if (exists) {
+                    return this.handleResult(data);
+                }
+            }
+            return api(this.handleApiCallSuccess, args, {
+                error_callback: this.handleError,
+            });
+        };
+        this.checkCache = () => {
+            let exists = false, data = null;
+            try {
+                if (utilities_1.StorageUtils.isStorageAvailable() && sessionStorage.getItem(this.cacheId)) {
+                    const { cacheDuration = this.defaultCacheDuration } = this.methodArgs;
+                    const cacheData = JSON.parse(sessionStorage.getItem(this.cacheId));
+                    const timeDiff = Math.floor((new Date().getTime() - new Date(cacheData.storeTime).getTime()) / 1000 / 60);
+                    if (timeDiff <= cacheDuration) {
+                        exists = true;
+                        data = cacheData.data;
+                    }
+                }
+            }
+            catch (e) { }
+            return { exists, data };
+        };
+        this.storeCache = (data) => {
+            try {
+                if (utilities_1.StorageUtils.isStorageAvailable()) {
+                    const cacheData = JSON.stringify({ storeTime: new Date(), data: data });
+                    sessionStorage.setItem(this.cacheId, cacheData);
+                }
+            }
+            catch (e) { }
+        };
+        const { skip, loader: showLoader } = this.methodArgs;
+        this.loader = (this.config.loader || showLoader) && !(skip === null || skip === void 0 ? void 0 : skip.loader) ? Loader_1.Loader.getInstance() : undefined;
+        this.cacheId =
+            "dajaxice-cache-" + (0, utilities_1.toHashCode)(JSON.stringify({ api: `${module}.${method}`, args: this.methodArgs.args }));
+    }
+    execute() {
+        const { skip } = this.methodArgs;
+        const { authCheck } = this.config;
+        const methodName = window["Dajaxice"][this.module][this.method];
+        if (methodName) {
+            this.showLoader();
+            if ((skip === null || skip === void 0 ? void 0 : skip.authCheck) || !authCheck) {
+                this.callApi();
+            }
+            else {
+                (0, utilities_1.fnWithAuthCheck)(this.callApi, authCheck.url, authCheck.redirectUrl).catch(this.handleError);
+            }
+        }
+        else {
+            this.deferred.reject(new Error(`The method ${this.method} does not exist in the module ${this.module}`));
+        }
+        return this.deferred.promise;
+    }
+}
+exports.DajaxiceCall = DajaxiceCall;

package/dist/dajaxice/DajaxiceProxy.d.ts

@@ -0,0 +1,7 @@
+import { IDajaxiceProxy } from "./Proxy.interface";
+/**
+ * This function is used to create a type safe proxy for the Dajaxice functions.
+ * @returns A type safe proxy for calling Dajaxice functions.
+ * @param config
+ */
+export declare const DajaxiceProxy: <TModule>(config: IDajaxiceProxy<TModule>) => TModule;

package/dist/dajaxice/DajaxiceProxy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DajaxiceProxy = void 0;
+const DajaxiceCall_1 = require("./DajaxiceCall");
+/**
+ * This function is used to create a type safe proxy for the Dajaxice functions.
+ * @returns A type safe proxy for calling Dajaxice functions.
+ * @param config
+ */
+const DajaxiceProxy = (config) => new Proxy(config.modules, {
+    get(target, module) {
+        return new Proxy({}, {
+            get(target, method) {
+                return (methodArgs = {}) => new DajaxiceCall_1.DajaxiceCall(module, method, config, methodArgs).execute();
+            },
+        });
+    },
+});
+exports.DajaxiceProxy = DajaxiceProxy;

package/dist/{helpers → dajaxice}/DajaxiceProxy.test.d.ts

@@ -1,4 +1,4 @@
-import { DajaxiceFn } from "./DajaxiceProxy";
+import { DajaxiceFn } from "./Proxy.interface";
 export declare const modules: DajaxiceModules;
 export declare type DajaxiceModules = {
     employee?: {

package/dist/{helpers → dajaxice}/DajaxiceProxy.test.js

@@ -6,7 +6,7 @@ exports.modules = {};
 const Api = (0, DajaxiceProxy_1.DajaxiceProxy)({
     modules: exports.modules,
 });
-Api.employee.getDetails({ args: { id: 1 } }).then(res => {
+Api.employee.getDetails({ args: { id: 1 }, loader: true }).then(res => {
     console.log(res.name, res.id);
 });
 Api.organization.setName({ args: { name: "test" } }).then(res => {

package/dist/{helpers/DajaxiceProxy.d.ts → dajaxice/Proxy.interface.d.ts}

@@ -1,4 +1,4 @@
-declare type Args<T = void> = {
+export declare type Args<T = void> = {
     args: T;
     /**
      * If true, it will show a loader when a Dajaxice function is called. Defaults to false.
@@ -29,15 +29,8 @@ declare type Args<T = void> = {
 };
 declare type ArgType<T> = T extends void ? Omit<Args, "args"> | void : Args<T>;
 export declare type DajaxiceFn<TArgs = void> = <TResult = any>(args: ArgType<TArgs>) => Promise<TResult>;
-/**
- * This function is used to create a type safe proxy for the Dajaxice functions.
- * @param modules: The modules object from the Dajaxice generated file.
- * @param authCheck The auth check object. If undefined, it will not check for authentication.
- * @param onError: Default handler for error
- * @param loader: If true, it will show a loader when a Dajaxice function is called.
- * @returns A type safe proxy for calling Dajaxice functions.
- */
-export declare const DajaxiceProxy: <TModule>({ modules, authCheck, onError, loader, }: {
+export declare type MethodArgs = Partial<Args<any>>;
+export interface IDajaxiceProxy<TModule> {
     modules: TModule;
     authCheck?: {
         url: string;
@@ -45,5 +38,5 @@ export declare const DajaxiceProxy: <TModule>({ modules, authCheck, onError, loa
     };
     onError?: (error: any) => void;
     loader?: boolean;
-}) => TModule;
+}
 export {};

package/dist/dajaxice/Proxy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/helpers/utilities.d.ts

@@ -40,3 +40,16 @@ export declare const StorageUtils: {
     isStorageAvailable: () => boolean;
 };
 export declare const toHashCode: (input: string) => number;
+export declare const insertUrlParam: (key: string, value: any) => void;
+export declare const insertUrlParams: (params: {
+    [key: string]: any;
+}) => void;
+export declare const getUrlParams: <T>() => T;
+export declare class Deferred<T> {
+    _resolve: (result: T) => void;
+    _reject: (error: any) => void;
+    readonly promise: Promise<T>;
+    constructor();
+    get resolve(): (result: T) => void;
+    get reject(): (error: any) => void;
+}

package/dist/helpers/utilities.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHashCode = exports.StorageUtils = exports.fnWithAuthCheck = exports.formatDollar = exports.useCountdown = exports.importStyleSheet = exports.importScript = exports.preventDefault = void 0;
+exports.Deferred = exports.getUrlParams = exports.insertUrlParams = exports.insertUrlParam = exports.toHashCode = exports.StorageUtils = exports.fnWithAuthCheck = exports.formatDollar = exports.useCountdown = exports.importStyleSheet = exports.importScript = exports.preventDefault = void 0;
 const React = require("react");
 /**
  * Returns a function that will call the given handler and prevent the default event behavior.
@@ -129,3 +129,43 @@ const toHashCode = (input) => {
     return hash;
 };
 exports.toHashCode = toHashCode;
+const insertUrlParam = (key, value) => {
+    if (history.pushState) {
+        let searchParams = new URLSearchParams(window.location.search);
+        searchParams.set(key, value);
+        let newUrl = window.location.protocol +
+            "//" +
+            window.location.host +
+            window.location.pathname +
+            "?" +
+            searchParams.toString();
+        window.history.pushState({ path: newUrl }, "", newUrl);
+    }
+};
+exports.insertUrlParam = insertUrlParam;
+const insertUrlParams = (params) => Object.keys(params).forEach(key => (0, exports.insertUrlParam)(key, params[key]));
+exports.insertUrlParams = insertUrlParams;
+const getUrlParams = () => {
+    const searchParams = new URLSearchParams(window.location.search);
+    const params = {};
+    for (const [key, value] of searchParams.entries()) {
+        params[key] = value;
+    }
+    return params;
+};
+exports.getUrlParams = getUrlParams;
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+    }
+    get resolve() {
+        return this._resolve;
+    }
+    get reject() {
+        return this._reject;
+    }
+}
+exports.Deferred = Deferred;

package/dist/index.d.ts

@@ -6,7 +6,8 @@ export { DryUXProvider } from "./provider";
 export * from "./helpers/utilities";
 export { classSet } from "./helpers/classSet";
 export { flatten, unflatten } from "./helpers/flat";
-export { DajaxiceFn, DajaxiceProxy } from "./helpers/DajaxiceProxy";
+export { DajaxiceProxy } from "./dajaxice/DajaxiceProxy";
+export { DajaxiceFn } from "./dajaxice/Proxy.interface";
 export { ErrorBoundary } from "./error/ErrorBoundary";
 export { ErrorScreen } from "./error/ErrorScreen";
 export { Loader } from "./ui-utils/Loader";

package/dist/index.js

@@ -31,7 +31,7 @@ Object.defineProperty(exports, "classSet", { enumerable: true, get: function ()
 var flat_1 = require("./helpers/flat");
 Object.defineProperty(exports, "flatten", { enumerable: true, get: function () { return flat_1.flatten; } });
 Object.defineProperty(exports, "unflatten", { enumerable: true, get: function () { return flat_1.unflatten; } });
-var DajaxiceProxy_1 = require("./helpers/DajaxiceProxy");
+var DajaxiceProxy_1 = require("./dajaxice/DajaxiceProxy");
 Object.defineProperty(exports, "DajaxiceProxy", { enumerable: true, get: function () { return DajaxiceProxy_1.DajaxiceProxy; } });
 var ErrorBoundary_1 = require("./error/ErrorBoundary");
 Object.defineProperty(exports, "ErrorBoundary", { enumerable: true, get: function () { return ErrorBoundary_1.ErrorBoundary; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dry-ux",
-  "version": "1.37.0",
+  "version": "1.39.0",
   "description": "",
   "main": "dist/index",
   "scripts": {

package/dist/helpers/DajaxiceProxy.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DajaxiceProxy = void 0;
-const utilities_1 = require("./utilities");
-const Loader_1 = require("../ui-utils/Loader");
-/**
- * This function is used to create a type safe proxy for the Dajaxice functions.
- * @param modules: The modules object from the Dajaxice generated file.
- * @param authCheck The auth check object. If undefined, it will not check for authentication.
- * @param onError: Default handler for error
- * @param loader: If true, it will show a loader when a Dajaxice function is called.
- * @returns A type safe proxy for calling Dajaxice functions.
- */
-const DajaxiceProxy = ({ modules, authCheck, onError, loader: showLoaderGlobal, }) => new Proxy(modules, {
-    get(target, module) {
-        return new Proxy({}, {
-            get(target, method) {
-                return function ({ args, skip, loader: showLoader, cache = false, cacheDuration = 15, } = {}) {
-                    return new Promise((resolve, reject) => {
-                        const methodName = window["Dajaxice"][module][method];
-                        const api = `${module}.${method}`;
-                        const loader = (showLoaderGlobal || showLoader) && !(skip === null || skip === void 0 ? void 0 : skip.loader)
-                            ? Loader_1.Loader.getInstance()
-                            : undefined;
-                        const hideLoader = () => {
-                            try {
-                                loader === null || loader === void 0 ? void 0 : loader.hide();
-                            }
-                            catch (e) { }
-                        };
-                        if (methodName) {
-                            const handleError = (e) => {
-                                try {
-                                    !(skip === null || skip === void 0 ? void 0 : skip.errorHandler) && (onError === null || onError === void 0 ? void 0 : onError(e));
-                                }
-                                catch (e) { }
-                                hideLoader();
-                                reject(e);
-                            };
-                            const handleSuccess = (result) => {
-                                handleResult(result);
-                                if (cache) {
-                                    storeCache(api, args, result);
-                                }
-                            };
-                            const handleResult = (result) => {
-                                hideLoader();
-                                resolve(result);
-                            };
-                            const fn = () => {
-                                if (cache) {
-                                    const cached = checkCache(api, args, cacheDuration);
-                                    if (cached.exists) {
-                                        handleResult(cached.data);
-                                        return;
-                                    }
-                                }
-                                return methodName(handleSuccess, args, {
-                                    error_callback: handleError,
-                                });
-                            };
-                            try {
-                                loader === null || loader === void 0 ? void 0 : loader.show();
-                            }
-                            catch (e) { }
-                            if ((skip === null || skip === void 0 ? void 0 : skip.authCheck) || !authCheck) {
-                                fn();
-                            }
-                            else {
-                                (0, utilities_1.fnWithAuthCheck)(fn, authCheck.url, authCheck.redirectUrl).catch(handleError);
-                            }
-                        }
-                        else {
-                            reject(new Error(`The method ${method} does not exist in the module ${module}`));
-                        }
-                    });
-                };
-            },
-        });
-    },
-});
-exports.DajaxiceProxy = DajaxiceProxy;
-const getCacheId = (api, args) => {
-    return "dajaxice-cache-" + (0, utilities_1.toHashCode)(JSON.stringify({ api, args }));
-};
-const checkCache = (api, args, cacheDuration) => {
-    const cacheId = getCacheId(api, args);
-    let exists = false, data = null;
-    if (utilities_1.StorageUtils.isStorageAvailable() && sessionStorage.getItem(cacheId)) {
-        const cacheData = JSON.parse(sessionStorage.getItem(cacheId));
-        const timeDiff = Math.floor((new Date().getTime() - new Date(cacheData.storeTime).getTime()) / 1000 / 60);
-        if (timeDiff <= cacheDuration) {
-            exists = true;
-            data = cacheData.data;
-        }
-    }
-    return { exists, data };
-};
-const storeCache = (api, args, data) => {
-    const cacheId = getCacheId(api, args);
-    if (utilities_1.StorageUtils.isStorageAvailable()) {
-        try {
-            const cacheData = JSON.stringify({ storeTime: new Date(), data: data });
-            sessionStorage.setItem(cacheId, cacheData);
-        }
-        catch (e) { }
-    }
-};