@elliemae/pui-app-sdk 5.16.3 → 5.17.0

package/dist/cjs/index.js

@@ -79,6 +79,7 @@ __export(lib_exports, {
   configureStore: () => import_store.createAppStore,
   createManager: () => import_redux_injectors.createManager,
   createSideEffect: () => import_listenerMiddleware.createSideEffect,
+  decorators: () => import_decorators.decorators,
   enableReactAppForHostIntegration: () => import_react2.enableReactAppForHostIntegration,
   endSession: () => import_auth.endSession,
   error: () => import_error.actions,
@@ -167,6 +168,7 @@ var import_react = require("./data/react.js");
 var import_use_state_selector = require("./utils/custom-hooks/use-state-selector.js");
 var import_errorMiddleware = require("./data/errorMiddleware.js");
 var import_listenerMiddleware = require("./data/listenerMiddleware.js");
+var import_decorators = require("./utils/decorators");
 var import_helper = require("./utils/auth/helper.js");
 var import_url = require("./utils/url.js");
 var import_store = require("./data/store.js");

package/dist/cjs/utils/decorators/classDecorators.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var classDecorators_exports = {};
+__export(classDecorators_exports, {
+  Mixins: () => Mixins,
+  Singleton: () => Singleton
+});
+module.exports = __toCommonJS(classDecorators_exports);
+function Mixins(...constructors) {
+  return (derivedCtor) => {
+    constructors.forEach((baseCtor) => {
+      Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+        Object.defineProperty(
+          derivedCtor.prototype,
+          name,
+          Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+        );
+      });
+      Object.getOwnPropertyNames(baseCtor).forEach((name) => {
+        if (name !== "prototype" && name !== "name" && name !== "length") {
+          Object.defineProperty(
+            derivedCtor,
+            name,
+            Object.getOwnPropertyDescriptor(baseCtor, name) || /* @__PURE__ */ Object.create(null)
+          );
+        }
+      });
+    });
+  };
+}
+const SINGLETON_KEY = Symbol("singleton");
+function Singleton(type) {
+  return new Proxy(type, {
+    construct(target, argsList, newTarget) {
+      if (target.prototype !== newTarget.prototype) {
+        return Reflect.construct(target, argsList, newTarget);
+      }
+      if (!target[SINGLETON_KEY]) {
+        target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget);
+      }
+      return target[SINGLETON_KEY];
+    }
+  });
+}

package/dist/cjs/utils/decorators/functionDecorators.js

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functionDecorators_exports = {};
+__export(functionDecorators_exports, {
+  CacheUntilResolved: () => CacheUntilResolved,
+  Debounce: () => Debounce,
+  ImmutableArgs: () => ImmutableArgs,
+  Memoize: () => Memoize,
+  MemoizeAsync: () => MemoizeAsync,
+  QueueTask: () => QueueTask,
+  Throttle: () => Throttle
+});
+module.exports = __toCommonJS(functionDecorators_exports);
+function CacheUntilResolved(_target, propertyKey, descriptor) {
+  const promiseMap = /* @__PURE__ */ new Map();
+  const originalMethod = descriptor.value;
+  descriptor.value = function(...args) {
+    const key = `${propertyKey}_${JSON.stringify(args)}`;
+    if (promiseMap.has(key)) {
+      return promiseMap.get(key);
+    }
+    const resultPromise = originalMethod.apply(this, args);
+    promiseMap.set(key, resultPromise);
+    resultPromise.finally(() => {
+      promiseMap.delete(key);
+    });
+    return resultPromise;
+  };
+  return descriptor;
+}
+function Debounce(delay = 300) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    let timeoutId;
+    descriptor.value = function(...args) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = window.setTimeout(() => {
+        originalMethod.apply(this, args);
+      }, delay);
+    };
+    return descriptor;
+  };
+}
+function ImmutableArgs(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function(...args) {
+    const changedArgs = args.map((arg) => {
+      if (arg && typeof arg === "object") {
+        arg = JSON.parse(JSON.stringify(arg));
+      }
+      return arg;
+    });
+    return originalMethod.apply(this, changedArgs);
+  };
+  return descriptor;
+}
+function Memoize(_target, _key, descriptor) {
+  const originalMethod = descriptor.value;
+  const cache = /* @__PURE__ */ new Map();
+  descriptor.value = function value(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = originalMethod.call(this, ...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+function MemoizeAsync(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value || descriptor.get;
+  const cache = /* @__PURE__ */ new Map();
+  if (typeof originalMethod !== "function") {
+    throw new Error("Decorator can only be applied to methods or getters");
+  }
+  if (descriptor.value) {
+    descriptor.value = async function(...args) {
+      const cacheKey = JSON.stringify(args);
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      const resultPromise = originalMethod.apply(this, args);
+      cache.set(cacheKey, resultPromise);
+      try {
+        const result = await resultPromise;
+        return result;
+      } catch (error) {
+        cache.delete(cacheKey);
+        throw error;
+      }
+    };
+  } else if (descriptor.get) {
+    descriptor.get = async function() {
+      const cacheKey = "getter";
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      const resultPromise = originalMethod.apply(this);
+      cache.set(cacheKey, resultPromise);
+      try {
+        const result = await resultPromise;
+        return result;
+      } catch (error) {
+        cache.delete(cacheKey);
+        throw error;
+      }
+    };
+  }
+  return descriptor;
+}
+function QueueTask(_target, _key, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function value(...args) {
+    queueMicrotask(() => {
+      originalMethod.call(this, ...args);
+    });
+  };
+}
+function Throttle(delay = 300) {
+  let lastCall = 0;
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const now = Date.now();
+      if (now - lastCall >= delay) {
+        lastCall = now;
+        originalMethod.apply(this, args);
+      }
+    };
+    return descriptor;
+  };
+}

package/dist/cjs/utils/decorators/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+__export(decorators_exports, {
+  decorators: () => decorators
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_classDecorators = require("./classDecorators");
+var import_functionDecorators = require("./functionDecorators");
+const decorators = {
+  class: {
+    Mixins: import_classDecorators.Mixins,
+    Singleton: import_classDecorators.Singleton
+  },
+  function: {
+    CacheUntilResolved: import_functionDecorators.CacheUntilResolved,
+    Debounce: import_functionDecorators.Debounce,
+    ImmutableArgs: import_functionDecorators.ImmutableArgs,
+    Memoize: import_functionDecorators.Memoize,
+    MemoizeAsync: import_functionDecorators.MemoizeAsync,
+    QueueTask: import_functionDecorators.QueueTask,
+    Throttle: import_functionDecorators.Throttle
+  }
+};

package/dist/esm/index.js

@@ -41,6 +41,7 @@ import {
   removeSideEffect,
   clearSideEffects
 } from "./data/listenerMiddleware.js";
+import { decorators } from "./utils/decorators";
 import { getAuthorizationHeader } from "./utils/auth/helper.js";
 import { getRedirectUrl, removeDoubleSlash } from "./utils/url.js";
 import { createAppStore } from "./data/store.js";
@@ -191,6 +192,7 @@ export {
   createAppStore as configureStore,
   createManager,
   createSideEffect,
+  decorators,
   enableReactAppForHostIntegration,
   endSession,
   actions2 as error,

package/dist/esm/utils/decorators/classDecorators.js

@@ -0,0 +1,40 @@
+function Mixins(...constructors) {
+  return (derivedCtor) => {
+    constructors.forEach((baseCtor) => {
+      Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+        Object.defineProperty(
+          derivedCtor.prototype,
+          name,
+          Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+        );
+      });
+      Object.getOwnPropertyNames(baseCtor).forEach((name) => {
+        if (name !== "prototype" && name !== "name" && name !== "length") {
+          Object.defineProperty(
+            derivedCtor,
+            name,
+            Object.getOwnPropertyDescriptor(baseCtor, name) || /* @__PURE__ */ Object.create(null)
+          );
+        }
+      });
+    });
+  };
+}
+const SINGLETON_KEY = Symbol("singleton");
+function Singleton(type) {
+  return new Proxy(type, {
+    construct(target, argsList, newTarget) {
+      if (target.prototype !== newTarget.prototype) {
+        return Reflect.construct(target, argsList, newTarget);
+      }
+      if (!target[SINGLETON_KEY]) {
+        target[SINGLETON_KEY] = Reflect.construct(target, argsList, newTarget);
+      }
+      return target[SINGLETON_KEY];
+    }
+  });
+}
+export {
+  Mixins,
+  Singleton
+};

package/dist/esm/utils/decorators/functionDecorators.js

@@ -0,0 +1,130 @@
+function CacheUntilResolved(_target, propertyKey, descriptor) {
+  const promiseMap = /* @__PURE__ */ new Map();
+  const originalMethod = descriptor.value;
+  descriptor.value = function(...args) {
+    const key = `${propertyKey}_${JSON.stringify(args)}`;
+    if (promiseMap.has(key)) {
+      return promiseMap.get(key);
+    }
+    const resultPromise = originalMethod.apply(this, args);
+    promiseMap.set(key, resultPromise);
+    resultPromise.finally(() => {
+      promiseMap.delete(key);
+    });
+    return resultPromise;
+  };
+  return descriptor;
+}
+function Debounce(delay = 300) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    let timeoutId;
+    descriptor.value = function(...args) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = window.setTimeout(() => {
+        originalMethod.apply(this, args);
+      }, delay);
+    };
+    return descriptor;
+  };
+}
+function ImmutableArgs(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function(...args) {
+    const changedArgs = args.map((arg) => {
+      if (arg && typeof arg === "object") {
+        arg = JSON.parse(JSON.stringify(arg));
+      }
+      return arg;
+    });
+    return originalMethod.apply(this, changedArgs);
+  };
+  return descriptor;
+}
+function Memoize(_target, _key, descriptor) {
+  const originalMethod = descriptor.value;
+  const cache = /* @__PURE__ */ new Map();
+  descriptor.value = function value(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = originalMethod.call(this, ...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+function MemoizeAsync(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value || descriptor.get;
+  const cache = /* @__PURE__ */ new Map();
+  if (typeof originalMethod !== "function") {
+    throw new Error("Decorator can only be applied to methods or getters");
+  }
+  if (descriptor.value) {
+    descriptor.value = async function(...args) {
+      const cacheKey = JSON.stringify(args);
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      const resultPromise = originalMethod.apply(this, args);
+      cache.set(cacheKey, resultPromise);
+      try {
+        const result = await resultPromise;
+        return result;
+      } catch (error) {
+        cache.delete(cacheKey);
+        throw error;
+      }
+    };
+  } else if (descriptor.get) {
+    descriptor.get = async function() {
+      const cacheKey = "getter";
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      const resultPromise = originalMethod.apply(this);
+      cache.set(cacheKey, resultPromise);
+      try {
+        const result = await resultPromise;
+        return result;
+      } catch (error) {
+        cache.delete(cacheKey);
+        throw error;
+      }
+    };
+  }
+  return descriptor;
+}
+function QueueTask(_target, _key, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function value(...args) {
+    queueMicrotask(() => {
+      originalMethod.call(this, ...args);
+    });
+  };
+}
+function Throttle(delay = 300) {
+  let lastCall = 0;
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const now = Date.now();
+      if (now - lastCall >= delay) {
+        lastCall = now;
+        originalMethod.apply(this, args);
+      }
+    };
+    return descriptor;
+  };
+}
+export {
+  CacheUntilResolved,
+  Debounce,
+  ImmutableArgs,
+  Memoize,
+  MemoizeAsync,
+  QueueTask,
+  Throttle
+};

package/dist/esm/utils/decorators/index.js

@@ -0,0 +1,28 @@
+import { Mixins, Singleton } from "./classDecorators";
+import {
+  CacheUntilResolved,
+  Debounce,
+  ImmutableArgs,
+  Memoize,
+  MemoizeAsync,
+  QueueTask,
+  Throttle
+} from "./functionDecorators";
+const decorators = {
+  class: {
+    Mixins,
+    Singleton
+  },
+  function: {
+    CacheUntilResolved,
+    Debounce,
+    ImmutableArgs,
+    Memoize,
+    MemoizeAsync,
+    QueueTask,
+    Throttle
+  }
+};
+export {
+  decorators
+};

package/dist/types/lib/index.d.ts

@@ -16,6 +16,7 @@ export { useStateSelector, useStateSelectorShallow, } from './utils/custom-hooks
 export type { UseStateSelectorOptions } from './utils/custom-hooks/use-state-selector.js';
 export { errorMiddleware } from './data/errorMiddleware.js';
 export { startSideEffect, createSideEffect, removeSideEffect, clearSideEffects, } from './data/listenerMiddleware.js';
+export { decorators } from './utils/decorators';
 export { getAuthorizationHeader } from './utils/auth/helper.js';
 export { getRedirectUrl, removeDoubleSlash } from './utils/url.js';
 export { createAppStore as configureStore } from './data/store.js';

package/dist/types/lib/utils/decorators/classDecorators.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A decorator to mix multiple classes into a single class.
+ * @param constructors - The constructors of the classes to be mixed in.
+ * @returns A class decorator that mixes the provided classes into the target class.
+ * @example
+ * class A {
+ *   methodA() {
+ *     console.log('A');
+ *   }
+ * }
+ *
+ * class B {
+ *   methodB() {
+ *     console.log('B');
+ *   }
+ * }
+ * @Mixins(A, B)
+ * class C {}
+ *
+ * const instance = new C();
+ * instance.methodA(); // Outputs: 'A'
+ * instance.methodB(); // Outputs: 'B'
+ */
+export declare function Mixins(...constructors: any[]): (derivedCtor: any) => void;
+declare const SINGLETON_KEY: unique symbol;
+/**
+ * A decorator to make a class a singleton.
+ * @param type - The class to be made a singleton.
+ * @returns A proxy that ensures only one instance of the class is created.
+ * @example
+ * @Singleton
+ * class MyClass {
+ *   constructor() {
+ *     console.log('Instance created');
+ *   }
+ * }
+ *
+ * const instance1 = new MyClass(); // Outputs: 'Instance created'
+ * const instance2 = new MyClass(); // No output, same instance returned
+ *
+ * console.log(instance1 === instance2); // Outputs: true
+ */
+export declare function Singleton<T extends new (...args: any[]) => any>(type: T): T & {
+    [SINGLETON_KEY]?: InstanceType<T>;
+};
+export {};

package/dist/types/lib/utils/decorators/functionDecorators.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Caches the result of a method until the promise is resolved.
+ * @param {any} _target - The target object.
+ * @param {string} propertyKey - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {PropertyDescriptor} The modified property descriptor.
+ * @example
+ * class Example {
+ *   @CacheUntilResolved
+ *   async fetchData() {
+ *     // ...fetch data...
+ *   }
+ * }
+ */
+export declare function CacheUntilResolved(_target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Debounces the method call by the specified delay.
+ * @param {number} [delay=300] - The delay in milliseconds.
+ * @returns {Function} A function that modifies the property descriptor.
+ * @example
+ * class Example {
+ *   @Debounce(500)
+ *   onResize() {
+ *     // ...handle resize...
+ *   }
+ * }
+ */
+export declare function Debounce(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Makes the arguments of a method immutable.
+ * @param {any} _target - The target object.
+ * @param {string | symbol} _propertyKey - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {PropertyDescriptor} The modified property descriptor.
+ * @example
+ * class Example {
+ *   @ImmutableArgs
+ *   updateData(data: any) {
+ *     // ...update data...
+ *   }
+ * }
+ */
+export declare function ImmutableArgs(_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Memoizes the result of a method.
+ * @param {any} _target - The target object.
+ * @param {string} _key - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {PropertyDescriptor} The modified property descriptor.
+ * @example
+ * class Example {
+ *   @Memoize
+ *   computeValue(x: number) {
+ *     return x * 2;
+ *   }
+ * }
+ */
+export declare function Memoize(_target: any, _key: string, descriptor: PropertyDescriptor): void;
+/**
+ * Memoizes the result of an async method.
+ * @param {any} _target - The target object.
+ * @param {string} _propertyKey - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {PropertyDescriptor} The modified property descriptor.
+ * @example
+ * class Example {
+ *   @MemoizeAsync
+ *   async fetchData() {
+ *     // ...fetch data...
+ *   }
+ * }
+ */
+export declare function MemoizeAsync(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Queues the method call as a microtask.
+ * @param {any} _target - The target object.
+ * @param {string} _key - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {PropertyDescriptor} The modified property descriptor.
+ * @example
+ * class Example {
+ *   @QueueTask
+ *   processTask() {
+ *     // ...process task...
+ *   }
+ * }
+ */
+export declare function QueueTask(_target: unknown, _key: string, descriptor: PropertyDescriptor): void;
+/**
+ * Throttles the method call by the specified delay.
+ * @param {number} [delay=300] - The delay in milliseconds.
+ * @returns {Function} A function that modifies the property descriptor.
+ * @example
+ * class Example {
+ *   @Throttle(500)
+ *   onScroll() {
+ *     // ...handle scroll...
+ *   }
+ * }
+ */
+export declare function Throttle(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/types/lib/utils/decorators/index.d.ts

@@ -0,0 +1,18 @@
+import { Mixins, Singleton } from './classDecorators';
+import { CacheUntilResolved, Debounce, ImmutableArgs, Memoize, MemoizeAsync, QueueTask, Throttle } from './functionDecorators';
+declare const decorators: {
+    class: {
+        Mixins: typeof Mixins;
+        Singleton: typeof Singleton;
+    };
+    function: {
+        CacheUntilResolved: typeof CacheUntilResolved;
+        Debounce: typeof Debounce;
+        ImmutableArgs: typeof ImmutableArgs;
+        Memoize: typeof Memoize;
+        MemoizeAsync: typeof MemoizeAsync;
+        QueueTask: typeof QueueTask;
+        Throttle: typeof Throttle;
+    };
+};
+export { decorators };

package/dist/types/lib/utils/decorators/tests/classDecorators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/decorators/tests/functionDecorators.test.d.ts

@@ -0,0 +1 @@
+export {};