@nlabs/arkhamjs 3.28.6 → 3.28.8

package/lib/Flux/Flux.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import { FluxAction, FluxMiddlewareType, FluxOptions, FluxStore } from './Flux.types';
+export declare class FluxFramework extends EventEmitter {
+    static initFlux: boolean;
+    isInit: boolean;
+    pluginTypes: string[];
+    private state;
+    private storeActions;
+    private defaultOptions;
+    private middleware;
+    private options;
+    constructor();
+    addMiddleware(middleware: FluxMiddlewareType[]): void;
+    clearAppData(): Promise<boolean>;
+    clearMiddleware(): boolean;
+    removeStores(storeNames: string[]): void;
+    dispatch(action: FluxAction, silent?: boolean): Promise<FluxAction>;
+    getOptions(): FluxOptions;
+    getState(path?: string | string[], defaultValue?: any): any;
+    getStore(name?: string): FluxStore;
+    init(options?: FluxOptions, reset?: boolean): Promise<FluxFramework>;
+    onInit(listener: (...args: any[]) => void): void;
+    offInit(listener: (...args: any[]) => void): void;
+    off(eventType: string, listener: (...args: any[]) => void): this;
+    on(eventType: string, listener: (...args: any[]) => void): this;
+    addStores(stores: any[]): Promise<object[]>;
+    removeMiddleware(names: string[]): void;
+    reset(clearStorage?: boolean): Promise<void>;
+    setState(path: string | string[], value: any): Promise<boolean>;
+    private addPlugin;
+    private deregister;
+    private register;
+    private removePlugin;
+    private updateStorage;
+    private useStorage;
+}
+export declare const Flux: FluxFramework;

package/lib/Flux/Flux.js

@@ -0,0 +1,486 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Flux_exports = {};
+__export(Flux_exports, {
+  Flux: () => Flux,
+  FluxFramework: () => FluxFramework
+});
+module.exports = __toCommonJS(Flux_exports);
+var import_error_stack_parser = __toESM(require("error-stack-parser"));
+var import_events = require("events");
+var import_debounce = __toESM(require("lodash/debounce"));
+var import_cloneDeep = __toESM(require("lodash/fp/cloneDeep"));
+var import_get = __toESM(require("lodash/fp/get"));
+var import_isEmpty = __toESM(require("lodash/fp/isEmpty"));
+var import_merge = __toESM(require("lodash/fp/merge"));
+var import_set = __toESM(require("lodash/fp/set"));
+var import_ArkhamConstants = require("../constants/ArkhamConstants");
+class FluxFramework extends import_events.EventEmitter {
+  /**
+   * Create a new instance of Flux.  Note that the Flux object
+   * is a Singleton pattern, so only one should ever exist.
+   *
+   * @constructor
+   * @this {FluxFramework}
+   */
+  constructor() {
+    super();
+    this.isInit = false;
+    // Public properties
+    this.pluginTypes = ["preDispatch", "postDispatch"];
+    // Private properties
+    this.state = {};
+    this.storeActions = {};
+    this.defaultOptions = {
+      name: "arkhamjs",
+      routerType: "browser",
+      scrollToTop: true,
+      state: null,
+      storage: null,
+      storageWait: 300,
+      stores: [],
+      title: "ArkhamJS"
+    };
+    this.middleware = {};
+    this.options = this.defaultOptions;
+    this.updateStorage = () => Promise.resolve(false);
+    this.addMiddleware = this.addMiddleware.bind(this);
+    this.addStores = this.addStores.bind(this);
+    this.clearAppData = this.clearAppData.bind(this);
+    this.clearMiddleware = this.clearMiddleware.bind(this);
+    this.deregister = this.deregister.bind(this);
+    this.dispatch = this.dispatch.bind(this);
+    this.getOptions = this.getOptions.bind(this);
+    this.getState = this.getState.bind(this);
+    this.getStore = this.getStore.bind(this);
+    this.init = this.init.bind(this);
+    this.off = this.off.bind(this);
+    this.register = this.register.bind(this);
+    this.removeMiddleware = this.removeMiddleware.bind(this);
+    this.removeStores = this.removeStores.bind(this);
+    this.reset = this.reset.bind(this);
+    this.setState = this.setState.bind(this);
+    this.pluginTypes.forEach((type) => this.middleware[`${type}List`] = []);
+  }
+  static {
+    this.initFlux = false;
+  }
+  /**
+   * Add middleware to framework.
+   *
+   * @param {array} middleware An array of middleware to add to the framework.
+   */
+  addMiddleware(middleware) {
+    middleware.forEach((middleObj) => {
+      if (!!middleObj && (typeof middleObj === "function" || typeof middleObj === "object")) {
+        const middleName = middleObj.name || "";
+        if (!middleName) {
+          throw Error("Unknown middleware is not configured properly. Requires name property. Cannot add to Flux.");
+        }
+        this.pluginTypes.forEach((type) => {
+          const method = middleObj[type];
+          const plugin = { method, name: middleName };
+          this.middleware[`${type}List`] = this.addPlugin(type, plugin);
+        });
+      } else {
+        throw Error("Unknown middleware is not configured properly. Cannot add to Flux.");
+      }
+    });
+  }
+  /**
+   * Remove all app data from storage.
+   *
+   * @returns {Promise<boolean>} Whether app data was successfully removed.
+   */
+  clearAppData() {
+    Object.keys(this.storeActions).forEach((storeName) => {
+      const storeFn = this.storeActions[storeName];
+      this.state[storeFn.name] = (0, import_cloneDeep.default)(storeFn.initialState);
+    });
+    const { name, storage } = this.options;
+    if (storage?.setStorageData) {
+      return storage.setStorageData(name, this.state);
+    }
+    return Promise.resolve(true);
+  }
+  /**
+   * Remove all middleware.
+   *
+   * @returns {boolean} Whether middleware was successfully removed.
+   */
+  clearMiddleware() {
+    Object.keys(this.middleware).forEach((pluginType) => {
+      this.middleware[pluginType] = [];
+    });
+    return true;
+  }
+  /**
+   * De-registers named stores.
+   *
+   * @param {array} storeNames An array of store names to remove from the framework.
+   */
+  removeStores(storeNames) {
+    storeNames.forEach((name) => this.deregister(name));
+  }
+  /**
+   * Dispatches an action to all stores.
+   *
+   * @param {object} action to dispatch to all the stores.
+   * @param {boolean} silent To silence any events.
+   * @returns {Promise} The promise is resolved when and if the app saves data to storage, returning
+   * the action.
+   */
+  async dispatch(action, silent = false) {
+    if (!action) {
+      throw new Error("ArkhamJS Error: Flux.dispatch requires an action.");
+    }
+    let clonedAction = (0, import_cloneDeep.default)(action);
+    const startTime = Date.now();
+    let stack = [];
+    try {
+      const stackProperty = "stackTraceLimit";
+      const { stackTraceLimit } = Error;
+      Error[stackProperty] = Infinity;
+      stack = import_error_stack_parser.default.parse(new Error());
+      Error[stackProperty] = stackTraceLimit;
+    } catch (error) {
+    }
+    const options = (0, import_cloneDeep.default)(this.options);
+    const appInfo = { duration: 0, options, stack };
+    const { postDispatchList = [], preDispatchList = [] } = this.middleware;
+    if (preDispatchList.length) {
+      clonedAction = await Promise.all(
+        preDispatchList.map(
+          (plugin) => plugin.method(
+            (0, import_cloneDeep.default)(clonedAction),
+            (0, import_cloneDeep.default)(this.state),
+            appInfo
+          )
+        )
+      ).then(
+        (actions) => actions.reduce((updatedAction, action2) => (0, import_merge.default)(updatedAction, action2), clonedAction)
+      ).catch((error) => {
+        throw error;
+      });
+    }
+    const { type, ...data } = clonedAction;
+    if (!type || type === "") {
+      console.warn("ArkhamJS Warning: Flux.dispatch is missing an action type for the payload:", data);
+      return Promise.resolve(clonedAction);
+    }
+    Object.keys(this.storeActions).forEach((storeName) => {
+      const storeFn = this.storeActions[storeName];
+      const state = (0, import_cloneDeep.default)(this.state[storeName]) || (0, import_cloneDeep.default)(storeFn.initialState) || {};
+      this.state[storeName] = (0, import_cloneDeep.default)(storeFn.action(type, data, state)) || state;
+    });
+    const { storage } = this.options;
+    if (storage && this.updateStorage) {
+      try {
+        await this.updateStorage();
+      } catch (error) {
+      }
+    }
+    const endTime = +/* @__PURE__ */ new Date();
+    const duration = endTime - startTime;
+    appInfo.duration = duration;
+    if (postDispatchList.length) {
+      clonedAction = await Promise.all(
+        postDispatchList.map(
+          async (plugin) => plugin.method((0, import_cloneDeep.default)(clonedAction), (0, import_cloneDeep.default)(this.state), appInfo)
+        )
+      ).then(
+        (actions) => actions.reduce((updatedAction, action2) => (0, import_merge.default)(updatedAction, action2), clonedAction)
+      ).catch((error) => {
+        throw error;
+      });
+    }
+    if (!silent) {
+      this.emit(type, clonedAction);
+      this.emit("arkhamjs", this.state);
+    }
+    return Promise.resolve(clonedAction);
+  }
+  /**
+   * Get the current Flux options.
+   *
+   * @returns {FluxOptions} the Flux options object.
+   */
+  getOptions() {
+    return this.options;
+  }
+  /**
+   * Get the current state object.
+   *
+   * @param {string|array} [name] (optional) The name of the store for an object, otherwise it will return all store
+   *   objects. You can also use an array to specify a property path within the object.
+   * @param {any} [defaultValue] (optional) A default value to return if null.
+   * @returns {any} the state object or a property value within.
+   */
+  getState(path = "", defaultValue) {
+    let storeValue;
+    if (!path) {
+      storeValue = this.state || {};
+    } else {
+      storeValue = (0, import_get.default)(path, this.state);
+    }
+    const value = storeValue ? (0, import_cloneDeep.default)(storeValue) : storeValue;
+    return value === void 0 ? defaultValue : value;
+  }
+  /**
+   * Get a store object registered with Flux.
+   *
+   * @param {string} name The name of the store.
+   * @returns {FluxStore} the store object.
+   */
+  getStore(name = "") {
+    return this.storeActions[name];
+  }
+  /**
+   * Initialize and set configuration options.
+   *
+   * @param {object} options Configuration options.
+   */
+  async init(options = {}, reset = false) {
+    if (reset) {
+      this.isInit = false;
+      this.reset(false);
+    }
+    const updatedOptions = { ...options };
+    if (this.isInit) {
+      updatedOptions.name = this.options.name;
+    }
+    this.options = { ...this.defaultOptions, ...updatedOptions };
+    const { debug, middleware, name, stores } = this.options;
+    try {
+      await this.useStorage(name);
+    } catch (error) {
+      console.error("Arkham Error: There was an error while using storage.", name);
+      throw error;
+    }
+    if (!!stores && stores.length) {
+      try {
+        await this.addStores(stores);
+      } catch (error) {
+        console.error("Arkham Error: There was an error while adding stores.", stores);
+        throw error;
+      }
+    }
+    if (!!middleware && middleware.length) {
+      this.addMiddleware(middleware);
+    }
+    const windowProperty = "arkhamjs";
+    if (debug) {
+      window[windowProperty] = this;
+    } else {
+      delete window[windowProperty];
+    }
+    this.isInit = true;
+    this.emit(import_ArkhamConstants.ArkhamConstants.INIT);
+    return this;
+  }
+  /**
+   * Adds an initialization listener.
+   *
+   * @param {function} [listener] The callback associated with the subscribed event.
+   */
+  onInit(listener) {
+    this.on(import_ArkhamConstants.ArkhamConstants.INIT, listener);
+    if (this.isInit) {
+      listener();
+    }
+  }
+  /**
+   * Removes the initialization listener.
+   *
+   * @param {function} [listener] The callback associated with the subscribed event.
+   */
+  offInit(listener) {
+    this.off(import_ArkhamConstants.ArkhamConstants.INIT, listener);
+  }
+  /**
+   * Removes an event listener.
+   *
+   * @param {string} [eventType] Event to unsubscribe.
+   * @param {function} [listener] The callback associated with the subscribed event.
+   */
+  off(eventType, listener) {
+    return this.removeListener(eventType, listener);
+  }
+  /**
+   * Adds an event listener.
+   *
+   * @param {string} [eventType] Event to subscribe.
+   * @param {function} [listener] The callback associated with the subscribed event.
+   */
+  on(eventType, listener) {
+    return this.addListener(eventType, listener);
+  }
+  /**
+   * Registers new Stores.
+   *
+   * @param {array} stores Store class.
+   * @returns {Promise<object[]>} the class object(s).
+   */
+  async addStores(stores) {
+    const registeredStores = stores.map((store) => this.register(store));
+    const { name, storage } = this.options;
+    if (storage?.setStorageData) {
+      try {
+        await storage.setStorageData(name, this.state);
+      } catch (error) {
+        throw error;
+      }
+    }
+    return registeredStores;
+  }
+  /**
+   * Remove middleware from framework.
+   *
+   * @param {array} string middleware names to remove.
+   * @returns {Promise<object[]>} the class object(s).
+   */
+  removeMiddleware(names) {
+    names.forEach((name) => {
+      this.pluginTypes.forEach((type) => {
+        this.middleware[`${type}List`] = this.removePlugin(type, name);
+      });
+    });
+  }
+  /**
+   * Reset framework.
+   *
+   * @param {array} string middleware names to remove.
+   * @returns {Promise<object[]>} the class object(s).
+   */
+  async reset(clearStorage = true) {
+    const { name, storage } = this.options;
+    if (storage && clearStorage) {
+      try {
+        await storage.setStorageData(name, {});
+      } catch (error) {
+        throw error;
+      }
+    }
+    this.middleware = {};
+    this.options = { ...this.defaultOptions };
+    this.state = {};
+    this.storeActions = {};
+    this.isInit = false;
+  }
+  /**
+   * Sets the current state object.
+   *
+   * @param {string|array} [name] The name of the store to set. You can also use an array to specify a property path
+   * within the object.
+   * @param {any} [value] The value to set.
+   */
+  setState(path = "", value) {
+    if (!!path) {
+      this.state = (0, import_set.default)(path, (0, import_cloneDeep.default)(value), this.state);
+    }
+    const { storage } = this.options;
+    if (storage && this.updateStorage) {
+      return this.updateStorage();
+    }
+    return Promise.resolve(false);
+  }
+  addPlugin(type, plugin) {
+    const list = this.middleware[`${type}List`] || [];
+    const { method, name } = plugin;
+    if (method && typeof method === "function") {
+      const exists = !!list.filter((obj) => obj.name === name).length;
+      if (!exists) {
+        list.push({ method, name });
+      }
+    } else if (method !== void 0) {
+      throw Error(`${plugin.name} middleware is not configured properly. Method is not a function.`);
+    }
+    return list;
+  }
+  deregister(name = "") {
+    delete this.storeActions[name];
+    delete this.state[name];
+  }
+  register(storeFn) {
+    if (!storeFn) {
+      throw Error("Store is undefined. Cannot register with Flux.");
+    }
+    const isFnc = typeof storeFn === "function";
+    if (!isFnc) {
+      throw Error(`${storeFn} is not a store function. Cannot register with Flux.`);
+    }
+    const { name } = storeFn;
+    const initialState = storeFn();
+    const storeAction = {
+      action: storeFn,
+      initialState: storeFn(),
+      name
+    };
+    if (!(0, import_isEmpty.default)(name) && !this.storeActions[name]) {
+      this.storeActions[name] = storeAction;
+      if (!this.state[name]) {
+        if (initialState) {
+          this.state[name] = (0, import_cloneDeep.default)(initialState);
+        } else {
+          this.state[name] = {};
+        }
+      }
+    }
+    return this.storeActions[name];
+  }
+  removePlugin(type, name) {
+    const list = this.middleware[`${type}List`] || [];
+    return list.filter((obj) => obj.name !== name);
+  }
+  async useStorage(name) {
+    const { storage, state, storageWait } = this.options;
+    if (storage) {
+      try {
+        this.state = state || await storage.getStorageData(name) || {};
+        this.updateStorage = (0, import_debounce.default)(
+          () => storage.setStorageData(name, this.state),
+          storageWait,
+          { leading: true, trailing: true }
+        );
+      } catch (error) {
+        console.error(`ArkhamJS Error: Using storage, "${name}".`);
+        throw error;
+      }
+    } else {
+      this.state = state || {};
+    }
+    return null;
+  }
+}
+const Flux = new FluxFramework();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Flux,
+  FluxFramework
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Flux/Flux.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport ErrorStackParser from 'error-stack-parser';\nimport {EventEmitter} from 'events';\nimport debounce from 'lodash/debounce';\nimport cloneDeep from 'lodash/fp/cloneDeep';\nimport get from 'lodash/fp/get';\nimport isEmpty from 'lodash/fp/isEmpty';\nimport merge from 'lodash/fp/merge';\nimport set from 'lodash/fp/set';\n\nimport {ArkhamConstants} from '../constants/ArkhamConstants';\nimport {FluxAction, FluxMiddlewareType, FluxOptions, FluxPluginType, FluxStore} from './Flux.types';\n\n/**\n * FluxFramework\n * @type {EventEmitter}\n */\nexport class FluxFramework extends EventEmitter {\n  static initFlux: boolean = false;\n  isInit: boolean = false;\n  // Public properties\n  pluginTypes: string[] = ['preDispatch', 'postDispatch'];\n  // Private properties\n  private state: any = {};\n  private storeActions: any = {};\n  private defaultOptions: FluxOptions = {\n    name: 'arkhamjs',\n    routerType: 'browser',\n    scrollToTop: true,\n    state: null,\n    storage: null,\n    storageWait: 300,\n    stores: [],\n    title: 'ArkhamJS'\n  };\n  private middleware: any = {};\n  private options: FluxOptions = this.defaultOptions;\n  /**\n   * Create a new instance of Flux.  Note that the Flux object\n   * is a Singleton pattern, so only one should ever exist.\n   *\n   * @constructor\n   * @this {FluxFramework}\n   */\n  constructor() {\n    super();\n\n    // Methods\n    this.addMiddleware = this.addMiddleware.bind(this);\n    this.addStores = this.addStores.bind(this);\n    this.clearAppData = this.clearAppData.bind(this);\n    this.clearMiddleware = this.clearMiddleware.bind(this);\n    this.deregister = this.deregister.bind(this);\n    this.dispatch = this.dispatch.bind(this);\n    this.getOptions = this.getOptions.bind(this);\n    this.getState = this.getState.bind(this);\n    this.getStore = this.getStore.bind(this);\n    this.init = this.init.bind(this);\n    this.off = this.off.bind(this);\n    this.register = this.register.bind(this);\n    this.removeMiddleware = this.removeMiddleware.bind(this);\n    this.removeStores = this.removeStores.bind(this);\n    this.reset = this.reset.bind(this);\n    this.setState = this.setState.bind(this);\n\n    // Add middleware plugin types\n    this.pluginTypes.forEach((type: string) => this.middleware[`${type}List`] = []);\n  }\n\n  /**\n   * Add middleware to framework.\n   *\n   * @param {array} middleware An array of middleware to add to the framework.\n   */\n  addMiddleware(middleware: FluxMiddlewareType[]): void {\n    middleware.forEach((middleObj: FluxMiddlewareType) => {\n      // Make sure middleware is either a class or object.\n      if(!!middleObj && ((typeof middleObj === 'function') || (typeof middleObj === 'object'))) {\n        const middleName: string = middleObj.name || '';\n\n        if(!middleName) {\n          throw Error('Unknown middleware is not configured properly. Requires name property. Cannot add to Flux.');\n        }\n\n        // Sort middleware plugins for efficiency\n        this.pluginTypes.forEach((type: string) => {\n          const method = middleObj[type];\n          const plugin: FluxPluginType = {method, name: middleName};\n          this.middleware[`${type}List`] = this.addPlugin(type, plugin);\n        });\n      } else {\n        throw Error('Unknown middleware is not configured properly. Cannot add to Flux.');\n      }\n    });\n  }\n\n  /**\n   * Remove all app data from storage.\n   *\n   * @returns {Promise<boolean>} Whether app data was successfully removed.\n   */\n  clearAppData(): Promise<boolean> {\n    // Set all store data to initial state\n    Object\n      .keys(this.storeActions)\n      .forEach((storeName: string) => {\n        const storeFn = this.storeActions[storeName];\n        this.state[storeFn.name] = cloneDeep(storeFn.initialState);\n      });\n\n    const {name, storage} = this.options;\n\n    if(storage?.setStorageData) {\n      return storage.setStorageData(name, this.state);\n    }\n\n    return Promise.resolve(true);\n  }\n\n  /**\n   * Remove all middleware.\n   *\n   * @returns {boolean} Whether middleware was successfully removed.\n   */\n  clearMiddleware(): boolean {\n    // Set all store data to initial state\n    Object\n      .keys(this.middleware)\n      .forEach((pluginType: string) => {\n        this.middleware[pluginType] = [];\n      });\n\n    return true;\n  }\n\n  /**\n   * De-registers named stores.\n   *\n   * @param {array} storeNames An array of store names to remove from the framework.\n   */\n  removeStores(storeNames: string[]): void {\n    storeNames.forEach((name: string) => this.deregister(name));\n  }\n\n  /**\n   * Dispatches an action to all stores.\n   *\n   * @param {object} action to dispatch to all the stores.\n   * @param {boolean} silent To silence any events.\n   * @returns {Promise} The promise is resolved when and if the app saves data to storage, returning\n   * the action.\n   */\n  async dispatch(action: FluxAction, silent: boolean = false): Promise<FluxAction> {\n    if(!action) {\n      throw new Error('ArkhamJS Error: Flux.dispatch requires an action.');\n    }\n\n    let clonedAction: FluxAction = cloneDeep(action);\n\n    // Log duration of dispatch\n    const startTime: number = Date.now();\n\n    // Get stack\n    let stack = [];\n\n    try {\n      const stackProperty: string = 'stackTraceLimit';\n      const {stackTraceLimit}: any = Error;\n      Error[stackProperty] = Infinity;\n      stack = ErrorStackParser.parse(new Error());\n      Error[stackProperty] = stackTraceLimit;\n    } catch(error) {}\n\n    // Get options\n    const options = cloneDeep(this.options);\n\n    // App info\n    const appInfo = {duration: 0, options, stack};\n\n    // Apply middleware before the action is processed\n    const {postDispatchList = [], preDispatchList = []} = this.middleware;\n\n    if(preDispatchList.length) {\n      clonedAction = await Promise\n        .all(\n          preDispatchList.map((plugin: FluxPluginType) => plugin.method(\n            cloneDeep(clonedAction), cloneDeep(this.state), appInfo)\n          )\n        )\n        .then(\n          (actions) => actions.reduce((updatedAction, action) =>\n            merge(updatedAction, action), clonedAction) as FluxAction\n        )\n        .catch((error) => {\n          throw error;\n        });\n    }\n\n    const {type, ...data} = clonedAction;\n\n    // Require a type\n    if(!type || type === '') {\n      console.warn('ArkhamJS Warning: Flux.dispatch is missing an action type for the payload:', data);\n      return Promise.resolve(clonedAction);\n    }\n\n    // When an action comes in, it must be completely handled by all stores\n    Object\n      .keys(this.storeActions)\n      .forEach((storeName: string) => {\n        const storeFn = this.storeActions[storeName];\n        const state = cloneDeep(this.state[storeName]) || cloneDeep(storeFn.initialState) || {};\n        this.state[storeName] = cloneDeep(storeFn.action(type, data, state)) || state;\n      });\n\n    // Save cache in storage\n    const {storage} = this.options;\n\n    if(storage && this.updateStorage) {\n      try {\n        await this.updateStorage();\n      } catch(error) {}\n    }\n\n    const endTime: number = +(new Date());\n    const duration: number = endTime - startTime;\n    appInfo.duration = duration;\n\n    if(postDispatchList.length) {\n      clonedAction = await Promise\n        .all(\n          postDispatchList.map(\n            async (plugin: FluxPluginType) => plugin.method(cloneDeep(clonedAction), cloneDeep(this.state), appInfo)\n          )\n        )\n        .then(\n          (actions) => actions.reduce((updatedAction, action) =>\n            merge(updatedAction, action), clonedAction) as FluxAction\n        )\n        .catch((error) => {\n          throw error;\n        });\n    }\n\n    if(!silent) {\n      this.emit(type, clonedAction);\n      this.emit('arkhamjs', this.state);\n    }\n\n    return Promise.resolve(clonedAction);\n  }\n\n  /**\n   * Get the current Flux options.\n   *\n   * @returns {FluxOptions} the Flux options object.\n   */\n  getOptions(): FluxOptions {\n    return this.options;\n  }\n\n  /**\n   * Get the current state object.\n   *\n   * @param {string|array} [name] (optional) The name of the store for an object, otherwise it will return all store\n   *   objects. You can also use an array to specify a property path within the object.\n   * @param {any} [defaultValue] (optional) A default value to return if null.\n   * @returns {any} the state object or a property value within.\n   */\n  getState(path: string | string[] = '', defaultValue?): any {\n    let storeValue;\n\n    if(!path) {\n      storeValue = this.state || {};\n    } else {\n      storeValue = get(path, this.state);\n    }\n\n    const value = storeValue ? cloneDeep(storeValue) : storeValue;\n    return value === undefined ? defaultValue : value;\n  }\n\n  /**\n   * Get a store object registered with Flux.\n   *\n   * @param {string} name The name of the store.\n   * @returns {FluxStore} the store object.\n   */\n  getStore(name: string = ''): FluxStore {\n    return this.storeActions[name];\n  }\n\n  /**\n   * Initialize and set configuration options.\n   *\n   * @param {object} options Configuration options.\n   */\n  async init(options: FluxOptions = {}, reset: boolean = false): Promise<FluxFramework> {\n    // Should reset previous params\n    if(reset) {\n      this.isInit = false;\n      this.reset(false);\n    }\n\n    // Set options\n    const updatedOptions = {...options};\n\n    if(this.isInit) {\n      // Remove the name from options if already initialized, otherwise the root app will not be able to access\n      // the state tree\n      updatedOptions.name = this.options.name;\n    }\n\n    this.options = {...this.defaultOptions, ...updatedOptions};\n    const {debug, middleware, name, stores} = this.options;\n\n    // Update default store\n    try {\n      await this.useStorage(name);\n    } catch(error) {\n      console.error('Arkham Error: There was an error while using storage.', name);\n      throw error;\n    }\n\n    if(!!stores && stores.length) {\n      try {\n        await this.addStores(stores);\n      } catch(error) {\n        console.error('Arkham Error: There was an error while adding stores.', stores);\n        throw error;\n      }\n    }\n\n    if(!!middleware && middleware.length) {\n      this.addMiddleware(middleware);\n    }\n\n    const windowProperty: string = 'arkhamjs';\n\n    if(debug) {\n      window[windowProperty] = this;\n    } else {\n      delete window[windowProperty];\n    }\n\n    this.isInit = true;\n    this.emit(ArkhamConstants.INIT);\n\n    return this;\n  }\n\n  /**\n   * Adds an initialization listener.\n   *\n   * @param {function} [listener] The callback associated with the subscribed event.\n   */\n  onInit(listener: (...args: any[]) => void): void {\n    this.on(ArkhamConstants.INIT, listener);\n\n    if(this.isInit) {\n      listener();\n    }\n  }\n\n  /**\n   * Removes the initialization listener.\n   *\n   * @param {function} [listener] The callback associated with the subscribed event.\n   */\n  offInit(listener: (...args: any[]) => void): void {\n    this.off(ArkhamConstants.INIT, listener);\n  }\n\n  /**\n   * Removes an event listener.\n   *\n   * @param {string} [eventType] Event to unsubscribe.\n   * @param {function} [listener] The callback associated with the subscribed event.\n   */\n  off(eventType: string, listener: (...args: any[]) => void): this {\n    return this.removeListener(eventType, listener);\n  }\n\n  /**\n   * Adds an event listener.\n   *\n   * @param {string} [eventType] Event to subscribe.\n   * @param {function} [listener] The callback associated with the subscribed event.\n   */\n  on(eventType: string, listener: (...args: any[]) => void): this {\n    return this.addListener(eventType, listener);\n  }\n\n  /**\n   * Registers new Stores.\n   *\n   * @param {array} stores Store class.\n   * @returns {Promise<object[]>} the class object(s).\n   */\n  async addStores(stores: any[]): Promise<object[]> {\n    const registeredStores: FluxStore[] = stores.map((store: FluxStore) => this.register(store));\n\n    // Save cache in session storage\n    const {name, storage} = this.options;\n\n    if(storage?.setStorageData) {\n      try {\n        await storage.setStorageData(name, this.state);\n      } catch(error) {\n        throw error;\n      }\n    }\n\n    // Return classes\n    return registeredStores;\n  }\n\n  /**\n   * Remove middleware from framework.\n   *\n   * @param {array} string middleware names to remove.\n   * @returns {Promise<object[]>} the class object(s).\n   */\n  removeMiddleware(names: string[]): void {\n    names.forEach((name: string) => {\n      // Remove middleware plugins\n      this.pluginTypes.forEach((type: string) => {\n        this.middleware[`${type}List`] = this.removePlugin(type, name);\n      });\n    });\n  }\n\n  /**\n   * Reset framework.\n   *\n   * @param {array} string middleware names to remove.\n   * @returns {Promise<object[]>} the class object(s).\n   */\n  async reset(clearStorage: boolean = true): Promise<void> {\n    const {name, storage} = this.options;\n\n    // Clear persistent cache\n    if(storage && clearStorage) {\n      try {\n        await storage.setStorageData(name, {});\n      } catch(error) {\n        throw error;\n      }\n    }\n\n    // Clear all properties\n    this.middleware = {};\n    this.options = {...this.defaultOptions};\n    this.state = {};\n    this.storeActions = {};\n    this.isInit = false;\n  }\n\n  /**\n   * Sets the current state object.\n   *\n   * @param {string|array} [name] The name of the store to set. You can also use an array to specify a property path\n   * within the object.\n   * @param {any} [value] The value to set.\n   */\n  setState(path: string | string[] = '', value): Promise<boolean> {\n    if(!!path) {\n      this.state = set(path, cloneDeep(value), this.state);\n    }\n\n    // Update persistent cache\n    const {storage} = this.options;\n\n    if(storage && this.updateStorage) {\n      return this.updateStorage();\n    }\n\n    return Promise.resolve(false);\n  }\n\n  private addPlugin(type: string, plugin: FluxPluginType): FluxPluginType[] {\n    const list = this.middleware[`${type}List`] || [];\n    const {method, name} = plugin;\n\n    if(method && typeof method === 'function') {\n      // Check if plugin already exists\n      const exists: boolean = !!list.filter((obj: FluxPluginType) => obj.name === name).length;\n\n      // Do not add duplicate plugins\n      if(!exists) {\n        list.push({method, name});\n      }\n    } else if(method !== undefined) {\n      throw Error(`${plugin.name} middleware is not configured properly. Method is not a function.`);\n    }\n\n    return list;\n  }\n\n  private deregister(name: string = ''): void {\n    delete this.storeActions[name];\n    delete this.state[name];\n  }\n\n  private register(storeFn): FluxStore {\n    if(!storeFn) {\n      throw Error('Store is undefined. Cannot register with Flux.');\n    }\n\n    const isFnc: boolean = typeof storeFn === 'function';\n\n    if(!isFnc) {\n      throw Error(`${storeFn} is not a store function. Cannot register with Flux.`);\n    }\n\n    // Create store object\n    const {name} = storeFn;\n    const initialState: any = storeFn();\n    const storeAction = {\n      action: storeFn,\n      initialState: storeFn(),\n      name\n    };\n\n    if(!isEmpty(name) && !this.storeActions[name]) {\n      // Save store object\n      this.storeActions[name] = storeAction;\n\n      // Get default values\n      if(!this.state[name]) {\n        if(initialState) {\n          this.state[name] = cloneDeep(initialState);\n        } else {\n          this.state[name] = {};\n        }\n      }\n    }\n\n    // Return store class\n    return this.storeActions[name];\n  }\n\n  private removePlugin(type: string, name: string): FluxPluginType[] {\n    const list = this.middleware[`${type}List`] || [];\n\n    // remove all occurrences of the plugin\n    return list.filter((obj: FluxPluginType) => obj.name !== name);\n  }\n\n  private updateStorage = () => Promise.resolve(false);\n\n  private async useStorage(name: string): Promise<void> {\n    const {storage, state, storageWait} = this.options;\n\n    // Cache\n    if(storage) {\n      try {\n        this.state = state || await storage.getStorageData(name) || {};\n        this.updateStorage = debounce(\n          () => storage.setStorageData(name, this.state),\n          storageWait,\n          {leading: true, trailing: true}\n        );\n      } catch(error) {\n        console.error(`ArkhamJS Error: Using storage, \"${name}\".`);\n        throw error;\n      }\n    } else {\n      this.state = state || {};\n    }\n\n    return null;\n  }\n}\n\nexport const Flux: FluxFramework = new FluxFramework();\n"],
  "mappings": "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",
  "names": ["cloneDeep", "ErrorStackParser", "action", "merge", "get", "set", "isEmpty", "debounce"]
}


package/lib/Flux/Flux.types.d.ts

@@ -0,0 +1,47 @@
+export interface FluxOptions {
+    readonly basename?: string;
+    readonly context?: object;
+    readonly debug?: boolean;
+    readonly getUserConfirmation?: () => void;
+    readonly hashType?: 'slash' | 'noslash' | 'hashbang';
+    readonly history?: object;
+    readonly initialEntries?: any[];
+    readonly initialIndex?: number;
+    readonly keyLength?: number;
+    readonly location?: string | object;
+    readonly middleware?: FluxMiddlewareType[];
+    readonly name?: string;
+    readonly routerType?: string;
+    readonly scrollToTop?: boolean;
+    readonly state?: any;
+    readonly storage?: FluxStorageType;
+    readonly storageWait?: number;
+    readonly stores?: any[];
+    readonly title?: string;
+}
+export interface FluxAction {
+    readonly [key: string]: any;
+    readonly type: string;
+}
+export interface FluxStorageType {
+    readonly getStorageData: (key: string) => Promise<any>;
+    readonly setStorageData: (key: string, value: any) => Promise<boolean>;
+}
+export interface FluxStore {
+    readonly action: (type: string, data: any, state: any) => any;
+    readonly name: string;
+    readonly initialState: any;
+}
+export type FluxPluginMethodType = (action: FluxAction, store: object, appData?: object) => Promise<FluxAction>;
+export interface FluxMiddlewareType {
+    readonly name: string;
+    readonly preDispatch?: FluxPluginMethodType;
+    readonly postDispatch?: FluxPluginMethodType;
+}
+export interface FluxPluginType {
+    readonly name: string;
+    readonly method: FluxPluginMethodType;
+}
+export interface ErrorConstructor {
+    captureStackTrace(thisArg: any, func: any): void;
+}

package/lib/Flux/Flux.types.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 Flux_types_exports = {};
+module.exports = __toCommonJS(Flux_types_exports);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constants/ArkhamConstants.d.ts

@@ -0,0 +1,8 @@
+export declare class ArkhamConstants {
+    static readonly GO_BACK: string;
+    static readonly GO_REPLACE: string;
+    static readonly GOTO: string;
+    static readonly INIT: string;
+    static readonly UPDATE_TITLE: string;
+    static readonly UPDATE_VIEW: string;
+}

package/lib/constants/ArkhamConstants.js

@@ -0,0 +1,47 @@
+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 ArkhamConstants_exports = {};
+__export(ArkhamConstants_exports, {
+  ArkhamConstants: () => ArkhamConstants
+});
+module.exports = __toCommonJS(ArkhamConstants_exports);
+class ArkhamConstants {
+  static {
+    this.GO_BACK = "ARKHAM_GO_BACK";
+  }
+  static {
+    this.GO_REPLACE = "ARKHAM_GO_REPLACE";
+  }
+  static {
+    this.GOTO = "ARKHAM_GOTO";
+  }
+  static {
+    this.INIT = "ARKHAM_INIT";
+  }
+  static {
+    this.UPDATE_TITLE = "ARKHAM_UPDATE_TITLE";
+  }
+  static {
+    this.UPDATE_VIEW = "ARKHAM_UPDATE_VIEW";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArkhamConstants
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2NvbnN0YW50cy9BcmtoYW1Db25zdGFudHMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE4LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5cbmV4cG9ydCBjbGFzcyBBcmtoYW1Db25zdGFudHMge1xuICBzdGF0aWMgcmVhZG9ubHkgR09fQkFDSzogc3RyaW5nID0gJ0FSS0hBTV9HT19CQUNLJztcbiAgc3RhdGljIHJlYWRvbmx5IEdPX1JFUExBQ0U6IHN0cmluZyA9ICdBUktIQU1fR09fUkVQTEFDRSc7XG4gIHN0YXRpYyByZWFkb25seSBHT1RPOiBzdHJpbmcgPSAnQVJLSEFNX0dPVE8nO1xuICBzdGF0aWMgcmVhZG9ubHkgSU5JVDogc3RyaW5nID0gJ0FSS0hBTV9JTklUJztcbiAgc3RhdGljIHJlYWRvbmx5IFVQREFURV9USVRMRTogc3RyaW5nID0gJ0FSS0hBTV9VUERBVEVfVElUTEUnO1xuICBzdGF0aWMgcmVhZG9ubHkgVVBEQVRFX1ZJRVc6IHN0cmluZyA9ICdBUktIQU1fVVBEQVRFX1ZJRVcnO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBS08sTUFBTSxnQkFBZ0I7QUFBQSxFQUMzQjtBQUFBLFNBQWdCLFVBQWtCO0FBQUE7QUFBQSxFQUNsQztBQUFBLFNBQWdCLGFBQXFCO0FBQUE7QUFBQSxFQUNyQztBQUFBLFNBQWdCLE9BQWU7QUFBQTtBQUFBLEVBQy9CO0FBQUEsU0FBZ0IsT0FBZTtBQUFBO0FBQUEsRUFDL0I7QUFBQSxTQUFnQixlQUF1QjtBQUFBO0FBQUEsRUFDdkM7QUFBQSxTQUFnQixjQUFzQjtBQUFBO0FBQ3hDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import { ArkhamConstants } from './constants/ArkhamConstants';
+import { Flux, FluxFramework } from './Flux/Flux';
+export * from './Flux/Flux.types';
+export { ArkhamConstants, Flux, FluxFramework };

package/lib/index.js

@@ -0,0 +1,36 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  ArkhamConstants: () => import_ArkhamConstants.ArkhamConstants,
+  Flux: () => import_Flux.Flux,
+  FluxFramework: () => import_Flux.FluxFramework
+});
+module.exports = __toCommonJS(index_exports);
+var import_ArkhamConstants = require("./constants/ArkhamConstants");
+var import_Flux = require("./Flux/Flux");
+__reExport(index_exports, require("./Flux/Flux.types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArkhamConstants,
+  Flux,
+  FluxFramework,
+  ...require("./Flux/Flux.types")
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtBcmtoYW1Db25zdGFudHN9IGZyb20gJy4vY29uc3RhbnRzL0Fya2hhbUNvbnN0YW50cyc7XG5pbXBvcnQge0ZsdXgsIEZsdXhGcmFtZXdvcmt9IGZyb20gJy4vRmx1eC9GbHV4JztcblxuZXhwb3J0ICogZnJvbSAnLi9GbHV4L0ZsdXgudHlwZXMnO1xuZXhwb3J0IHtBcmtoYW1Db25zdGFudHMsIEZsdXgsIEZsdXhGcmFtZXdvcmt9O1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFJQSw2QkFBOEI7QUFDOUIsa0JBQWtDO0FBRWxDLDBCQUFjLDhCQVBkOyIsCiAgIm5hbWVzIjogW10KfQo=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/arkhamjs",
-  "version": "3.28.6",
+  "version": "3.28.8",
   "publishConfig": {
     "access": "public"
   },
@@ -58,5 +58,13 @@
     "eslint-config-styleguidejs": "^3.2.1",
     "typescript": "^5.7.3"
   },
+  "files": [
+    "lib",
+    "index.js",
+    "index.d.ts",
+    "LICENSE",
+    "package.json",
+    "README.md"
+  ],
   "gitHead": "fc371e1e28fe0ae35d40d29a217d5f0e990ec32a"
 }