@nlabs/arkhamjs 3.31.8 → 3.31.9

package/lib/Flux/Flux.d.ts

@@ -28,7 +28,7 @@ export declare class FluxFramework extends EventEmitter {
     addStores(stores: FluxStore[]): Promise<FluxStore[]>;
     removeMiddleware(names: string[]): void;
     reset(clearStorage?: boolean): Promise<void>;
-    setState(path: string | string[] | undefined, value: unknown): Promise<boolean>;
+    setState(path: string | string[], value: unknown): Promise<boolean>;
     private processMiddleware;
     private updateStorage;
     private updateStoresState;
@@ -40,3 +40,4 @@ export declare class FluxFramework extends EventEmitter {
     private useStorage;
 }
 export declare const Flux: FluxFramework;
+//# sourceMappingURL=Flux.d.ts.map

package/lib/Flux/Flux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flux.d.ts","sourceRoot":"","sources":["../../src/Flux/Flux.ts"],"names":[],"mappings":"AAUA,OAAO,EAAC,YAAY,EAAC,MAAM,QAAQ,CAAC;AAIpC,OAAO,KAAK,EAAC,UAAU,EAAE,kBAAkB,EAAE,WAAW,EAAkB,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAK5G,qBAAa,aAAc,SAAQ,YAAY;IAC7C,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAS;IACjC,MAAM,EAAE,OAAO,CAAS;IAExB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAA4C;IAEnF,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAO7B;IACF,OAAO,CAAC,UAAU,CAAwC;IAC1D,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,YAAY,CAAkB;;IA0BtC,aAAa,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,IAAI;IA8BrD,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAmBhC,eAAe,IAAI,OAAO;IAO1B,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlC,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC,UAAU,CAAC;IA6DhF,UAAU,IAAI,WAAW;IAIzB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,GAAE,MAAM,GAAG,MAAM,EAAO,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC;IAsBxE,QAAQ,CAAC,IAAI,GAAE,MAAW,GAAG,SAAS,GAAG,SAAS;IAI5C,IAAI,CAAC,OAAO,GAAE,WAAgB,EAAE,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAiDrF,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAQhD,OAAO,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAIxC,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAIhE,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI;IAIlE,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAe1D,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAQjC,KAAK,CAAC,YAAY,GAAE,OAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBxD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YAgB1D,iBAAiB;IAoB/B,OAAO,CAAC,aAAa,CAAwD;IAE7E,OAAO,CAAC,iBAAiB;IAezB,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,QAAQ;IA6ChB,OAAO,CAAC,YAAY;YAKN,UAAU;CAmBzB;AAED,eAAO,MAAM,IAAI,EAAE,aAAmC,CAAC"}

package/lib/Flux/Flux.js

@@ -0,0 +1,410 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { cloneDeep } from '@nlabs/utils/objects/clone';
+import { debounceCompact } from '@nlabs/utils/objects/debounce-compact';
+import { get } from '@nlabs/utils/objects/get';
+import { merge } from '@nlabs/utils/objects/merge';
+import { set } from '@nlabs/utils/objects/set';
+import { parseStack } from '@nlabs/utils/objects/stack-parser';
+import { EventEmitter } from 'events';
+import { ArkhamConstants } from '../constants/ArkhamConstants.js';
+const STACK_CACHE = new Map();
+const STACK_CACHE_SIZE = 100;
+export class FluxFramework extends EventEmitter {
+    addMiddleware(middleware) {
+        middleware.forEach((middleObj)=>{
+            if (!middleObj || typeof middleObj !== 'function' && typeof middleObj !== 'object') {
+                throw Error('Unknown middleware is not configured properly. Cannot add to Flux.');
+            }
+            const middleName = middleObj.name || '';
+            if (!middleName) {
+                throw Error('Unknown middleware is not configured properly. Requires name property. Cannot add to Flux.');
+            }
+            const existingMiddleware = this.middleware.preDispatchList?.find((m)=>m.name === middleName) || this.middleware.postDispatchList?.find((m)=>m.name === middleName);
+            if (existingMiddleware) {
+                // eslint-disable-next-line no-console
+                console.warn(`Middleware "${middleName}" already exists. Skipping duplicate.`);
+                return;
+            }
+            this.pluginTypes.forEach((type)=>{
+                const method = middleObj[type];
+                if (method && typeof method === 'function') {
+                    const plugin = {
+                        method,
+                        name: middleName
+                    };
+                    this.middleware[`${type}List`] = this.addPlugin(type, plugin);
+                }
+            });
+        });
+    }
+    clearAppData() {
+        Object.keys(this.storeActions).forEach((storeName)=>{
+            const storeFn = this.storeActions[storeName];
+            if (storeFn) {
+                this.state[storeFn.name] = storeFn.initialState;
+            }
+        });
+        this.stateCache.clear();
+        this.stateChanged = true;
+        const { name, storage } = this.options;
+        if (storage?.setStorageData) {
+            return storage.setStorageData(name ?? 'arkhamjs', this.state);
+        }
+        return Promise.resolve(true);
+    }
+    clearMiddleware() {
+        Object.keys(this.middleware).forEach((pluginType)=>{
+            this.middleware[pluginType] = [];
+        });
+        return true;
+    }
+    removeStores(storeNames) {
+        storeNames.forEach((name)=>this.deregister(name));
+    }
+    async dispatch(action, silent = false) {
+        if (!action) {
+            throw new Error('ArkhamJS Error: Flux.dispatch requires an action.');
+        }
+        const startTime = Date.now();
+        let clonedAction = cloneDeep(action);
+        let stack = [];
+        if (this.options.debug) {
+            stack = this.getCachedStack();
+        }
+        const appInfo = {
+            duration: 0,
+            options: this.options,
+            stack
+        };
+        const { postDispatchList = [], preDispatchList = [] } = this.middleware;
+        if (preDispatchList.length) {
+            clonedAction = await this.processMiddleware(preDispatchList, clonedAction, appInfo);
+        }
+        const { type, ...data } = clonedAction;
+        if (!type || type === '') {
+            // eslint-disable-next-line no-console
+            console.warn('ArkhamJS Warning: Flux.dispatch is missing an action type for the payload:', data);
+            return Promise.resolve(clonedAction);
+        }
+        this.updateStoresState(type, data);
+        if (this.stateChanged && this.options.storage && this.updateStorage) {
+            try {
+                await this.updateStorage();
+                this.stateChanged = false;
+            } catch (error) {
+                // eslint-disable-next-line no-console
+                console.error('Storage update failed:', error);
+            }
+        }
+        const duration = Date.now() - startTime;
+        appInfo.duration = duration;
+        if (postDispatchList.length) {
+            clonedAction = await this.processMiddleware(postDispatchList, clonedAction, appInfo);
+        }
+        if (!silent) {
+            this.emit(type, clonedAction);
+            this.emit('arkhamjs', this.state);
+        }
+        return Promise.resolve(clonedAction);
+    }
+    getOptions() {
+        return this.options;
+    }
+    getState(path = '', defaultValue) {
+        const pathKey = Array.isArray(path) ? path.join('.') : path;
+        if (this.stateCache.has(pathKey)) {
+            return this.stateCache.get(pathKey);
+        }
+        let storeValue;
+        if (!path) {
+            storeValue = this.state || {};
+        } else {
+            storeValue = get(this.state, path);
+        }
+        const value = storeValue ? cloneDeep(storeValue) : storeValue;
+        const result = value === undefined ? defaultValue : value;
+        this.stateCache.set(pathKey, result);
+        return result;
+    }
+    getStore(name = '') {
+        return this.storeActions[name];
+    }
+    async init(options = {}, reset = false) {
+        if (reset) {
+            this.isInit = false;
+            await this.reset(false);
+        }
+        const updatedOptions = {
+            ...options
+        };
+        if (this.isInit && this.options.name) {
+            updatedOptions.name = this.options.name;
+        }
+        this.options = {
+            ...this.defaultOptions,
+            ...updatedOptions
+        };
+        const { debug, middleware, name, stores } = this.options;
+        try {
+            await this.useStorage(name ?? 'arkhamjs');
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Arkham Error: There was an error while using storage.', name);
+            throw error;
+        }
+        if (stores?.length) {
+            try {
+                await this.addStores(stores);
+            } catch (error) {
+                // eslint-disable-next-line no-console
+                console.error('Arkham Error: There was an error while adding stores.', stores);
+                throw error;
+            }
+        }
+        if (middleware?.length) {
+            this.addMiddleware(middleware);
+        }
+        const windowProperty = 'arkhamjs';
+        if (debug) {
+            window[windowProperty] = this;
+        } else {
+            delete window[windowProperty];
+        }
+        this.isInit = true;
+        this.emit(ArkhamConstants.INIT);
+        return this;
+    }
+    onInit(listener) {
+        this.on(ArkhamConstants.INIT, listener);
+        if (this.isInit) {
+            listener();
+        }
+    }
+    offInit(listener) {
+        this.off(ArkhamConstants.INIT, listener);
+    }
+    off(eventType, listener) {
+        return this.removeListener(eventType, listener);
+    }
+    on(eventType, listener) {
+        return this.addListener(eventType, listener);
+    }
+    async addStores(stores) {
+        const registeredStores = stores.map((store)=>this.register(store));
+        const { name, storage } = this.options;
+        if (storage?.setStorageData) {
+            try {
+                await storage.setStorageData(name ?? 'arkhamjs', this.state);
+            } catch (error) {
+                throw error;
+            }
+        }
+        return registeredStores;
+    }
+    removeMiddleware(names) {
+        names.forEach((name)=>{
+            this.pluginTypes.forEach((type)=>{
+                this.middleware[`${type}List`] = this.removePlugin(type, name);
+            });
+        });
+    }
+    async reset(clearStorage = true) {
+        const { name, storage } = this.options;
+        if (storage && clearStorage) {
+            try {
+                await storage.setStorageData?.(name ?? 'arkhamjs', {});
+            } catch (error) {
+                throw error;
+            }
+        }
+        this.middleware = {};
+        this.options = {
+            ...this.defaultOptions
+        };
+        this.state = {};
+        this.storeActions = {};
+        this.stateCache.clear();
+        this.stateChanged = false;
+        this.isInit = false;
+        this.pluginTypes.forEach((type)=>this.middleware[`${type}List`] = []);
+    }
+    setState(path = '', value) {
+        if (path) {
+            this.state = set(this.state, path, cloneDeep(value));
+            this.stateChanged = true;
+            const pathKey = Array.isArray(path) ? path.join('.') : path;
+            this.stateCache.delete(pathKey);
+        }
+        if (this.options.storage && this.updateStorage) {
+            return this.updateStorage();
+        }
+        return Promise.resolve(false);
+    }
+    async processMiddleware(middlewareList, action, appInfo) {
+        return Promise.all(middlewareList.map((plugin)=>plugin.method(cloneDeep(action), cloneDeep(this.state), appInfo))).then((actions)=>actions.reduce((updatedAction, action)=>merge(updatedAction, action), action)).catch((error)=>{
+            throw error;
+        });
+    }
+    updateStoresState(type, data) {
+        Object.keys(this.storeActions).forEach((storeName)=>{
+            const storeFn = this.storeActions[storeName];
+            if (storeFn) {
+                const currentState = this.state[storeName] || storeFn.initialState || {};
+                const newState = storeFn.action(type, data, currentState);
+                if (newState !== currentState) {
+                    this.state[storeName] = cloneDeep(newState) || currentState;
+                    this.stateChanged = true;
+                }
+            }
+        });
+    }
+    getCachedStack() {
+        const cacheKey = new Error().stack?.split('\n')[2] || '';
+        if (STACK_CACHE.has(cacheKey)) {
+            return STACK_CACHE.get(cacheKey);
+        }
+        let stack = [];
+        try {
+            const stackProperty = 'stackTraceLimit';
+            const originalLimit = Error.stackTraceLimit;
+            Error[stackProperty] = Infinity;
+            stack = parseStack(new Error());
+            Error[stackProperty] = originalLimit;
+            if (STACK_CACHE.size >= STACK_CACHE_SIZE) {
+                const firstKey = STACK_CACHE.keys().next().value;
+                if (firstKey) {
+                    STACK_CACHE.delete(firstKey);
+                }
+            }
+            STACK_CACHE.set(cacheKey, stack);
+        } catch (error) {}
+        return stack;
+    }
+    addPlugin(type, plugin) {
+        const list = this.middleware[`${type}List`] || [];
+        const { method, name } = plugin;
+        if (method && typeof method === 'function') {
+            const exists = list.some((obj)=>obj.name === name);
+            if (!exists) {
+                list.push({
+                    method,
+                    name
+                });
+            }
+        } else if (method !== undefined) {
+            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];
+        this.stateCache.clear(); // Clear cache when stores change
+    }
+    register(store) {
+        if (!store) {
+            throw Error('Store is undefined. Cannot register with Flux.');
+        }
+        let storeName;
+        let storeAction;
+        let initialState;
+        if (typeof store === 'function') {
+            // Function store - extract name from function.name
+            storeName = store.name || 'anonymous';
+            storeAction = store;
+            initialState = store();
+        } else if (typeof store?.action === 'function') {
+            // Object store with action method
+            storeName = store.name || 'anonymous';
+            storeAction = store.action;
+            initialState = store.initialState || store.action();
+        } else {
+            throw Error(`${store} is not a valid store. Must be a function or object with action method.`);
+        }
+        if (!storeName || storeName === 'anonymous') {
+            // Silently ignore anonymous stores - return undefined
+            return undefined;
+        }
+        const fluxStore = {
+            action: storeAction,
+            initialState,
+            name: storeName
+        };
+        if (!this.storeActions[storeName]) {
+            this.storeActions[storeName] = fluxStore;
+            if (!this.state[storeName]) {
+                this.state[storeName] = cloneDeep(initialState || {});
+            }
+        }
+        return this.storeActions[storeName];
+    }
+    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 = debounceCompact(()=>storage?.setStorageData?.(name, this.state), storageWait ?? 300);
+            } catch (error) {
+                // eslint-disable-next-line no-console
+                console.error(`ArkhamJS Error: Using storage, "${name}".`);
+                throw error;
+            }
+        } else {
+            this.state = state || {};
+        }
+    }
+    constructor(){
+        super(), _define_property(this, "isInit", false), _define_property(this, "pluginTypes", [
+            'preDispatch',
+            'postDispatch'
+        ]), _define_property(this, "state", {}), _define_property(this, "storeActions", {}), _define_property(this, "defaultOptions", {
+            name: 'arkhamjs',
+            routerType: 'browser',
+            scrollToTop: true,
+            storageWait: 300,
+            stores: [],
+            title: 'ArkhamJS'
+        }), _define_property(this, "middleware", {}), _define_property(this, "options", this.defaultOptions), _define_property(this, "stateCache", new Map()), _define_property(this, "stateChanged", false), _define_property(this, "updateStorage", ()=>Promise.resolve(false));
+        // Bind methods once in constructor for better performance
+        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`] = []);
+    }
+}
+_define_property(FluxFramework, "initFlux", false);
+export const Flux = new FluxFramework();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/arkhamjs/packages/arkhamjs/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 {cloneDeep} from '@nlabs/utils/objects/clone';\nimport {debounceCompact} from '@nlabs/utils/objects/debounce-compact';\nimport {get} from '@nlabs/utils/objects/get';\nimport {merge} from '@nlabs/utils/objects/merge';\nimport {set} from '@nlabs/utils/objects/set';\nimport {parseStack} from '@nlabs/utils/objects/stack-parser';\nimport {EventEmitter} from 'events';\n\nimport {ArkhamConstants} from '../constants/ArkhamConstants.js';\n\nimport type {FluxAction, FluxMiddlewareType, FluxOptions, FluxPluginType, FluxStore} from './Flux.types.js';\n\nconst STACK_CACHE = new Map<string, any[]>();\nconst STACK_CACHE_SIZE = 100;\n\nexport class FluxFramework extends EventEmitter {\n  static initFlux: boolean = false;\n  isInit: boolean = false;\n\n  readonly pluginTypes: readonly string[] = ['preDispatch', 'postDispatch'] as const;\n\n  private state: Record<string, any> = {};\n  private storeActions: Record<string, FluxStore> = {};\n  private readonly defaultOptions: FluxOptions = {\n    name: 'arkhamjs',\n    routerType: 'browser',\n    scrollToTop: true,\n    storageWait: 300,\n    stores: [],\n    title: 'ArkhamJS'\n  };\n  private middleware: Record<string, FluxPluginType[]> = {};\n  private options: FluxOptions = this.defaultOptions;\n  private stateCache: Map<string, any> = new Map();\n  private stateChanged: boolean = false;\n\n  constructor() {\n    super();\n\n    // Bind methods once in constructor for better performance\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    this.pluginTypes.forEach((type: string) => this.middleware[`${type}List`] = []);\n  }\n\n  addMiddleware(middleware: FluxMiddlewareType[]): void {\n    middleware.forEach((middleObj: FluxMiddlewareType) => {\n      if(!middleObj || (typeof middleObj !== 'function' && typeof middleObj !== 'object')) {\n        throw Error('Unknown middleware is not configured properly. Cannot add to Flux.');\n      }\n\n      const middleName: string = middleObj.name || '';\n      if(!middleName) {\n        throw Error('Unknown middleware is not configured properly. Requires name property. Cannot add to Flux.');\n      }\n\n      const existingMiddleware = this.middleware.preDispatchList?.find((m) => m.name === middleName) ||\n                                this.middleware.postDispatchList?.find((m) => m.name === middleName);\n\n      if(existingMiddleware) {\n        // eslint-disable-next-line no-console\n        console.warn(`Middleware \"${middleName}\" already exists. Skipping duplicate.`);\n        return;\n      }\n\n      this.pluginTypes.forEach((type: string) => {\n        const method = middleObj[type as keyof FluxMiddlewareType];\n        if(method && typeof method === 'function') {\n          const plugin: FluxPluginType = {method, name: middleName};\n          this.middleware[`${type}List`] = this.addPlugin(type, plugin);\n        }\n      });\n    });\n  }\n\n  clearAppData(): Promise<boolean> {\n    Object.keys(this.storeActions).forEach((storeName: string) => {\n      const storeFn = this.storeActions[storeName];\n      if(storeFn) {\n        this.state[storeFn.name] = storeFn.initialState;\n      }\n    });\n\n    this.stateCache.clear();\n    this.stateChanged = true;\n\n    const {name, storage} = this.options;\n    if(storage?.setStorageData) {\n      return storage.setStorageData(name ?? 'arkhamjs', this.state);\n    }\n\n    return Promise.resolve(true);\n  }\n\n  clearMiddleware(): boolean {\n    Object.keys(this.middleware).forEach((pluginType: string) => {\n      this.middleware[pluginType] = [];\n    });\n    return true;\n  }\n\n  removeStores(storeNames: string[]): void {\n    storeNames.forEach((name: string) => this.deregister(name));\n  }\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    const startTime: number = Date.now();\n\n    let clonedAction: FluxAction = cloneDeep(action);\n\n    let stack: any[] = [];\n    if(this.options.debug) {\n      stack = this.getCachedStack();\n    }\n\n    const appInfo = {\n      duration: 0,\n      options: this.options,\n      stack\n    };\n\n    const {postDispatchList = [], preDispatchList = []} = this.middleware;\n\n    if(preDispatchList.length) {\n      clonedAction = await this.processMiddleware(preDispatchList, clonedAction, appInfo);\n    }\n\n    const {type, ...data} = clonedAction;\n\n    if(!type || type === '') {\n      // eslint-disable-next-line no-console\n      console.warn('ArkhamJS Warning: Flux.dispatch is missing an action type for the payload:', data);\n      return Promise.resolve(clonedAction);\n    }\n\n    this.updateStoresState(type, data);\n\n    if(this.stateChanged && this.options.storage && this.updateStorage) {\n      try {\n        await this.updateStorage();\n        this.stateChanged = false;\n      } catch(error) {\n        // eslint-disable-next-line no-console\n        console.error('Storage update failed:', error);\n      }\n    }\n\n    const duration: number = Date.now() - startTime;\n    appInfo.duration = duration;\n\n    if(postDispatchList.length) {\n      clonedAction = await this.processMiddleware(postDispatchList, clonedAction, appInfo);\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  getOptions(): FluxOptions {\n    return this.options;\n  }\n\n  getState<T = unknown>(path: string | string[] = '', defaultValue?: T): T {\n    const pathKey = Array.isArray(path) ? path.join('.') : path;\n\n    if(this.stateCache.has(pathKey)) {\n      return this.stateCache.get(pathKey) as T;\n    }\n\n    let storeValue: unknown;\n    if(!path) {\n      storeValue = this.state || {};\n    } else {\n      storeValue = get(this.state, path);\n    }\n\n    const value = storeValue ? cloneDeep(storeValue) : storeValue;\n    const result = value === undefined ? defaultValue : value;\n\n    this.stateCache.set(pathKey, result);\n\n    return result as T;\n  }\n\n  getStore(name: string = ''): FluxStore | undefined {\n    return this.storeActions[name];\n  }\n\n  async init(options: FluxOptions = {}, reset: boolean = false): Promise<FluxFramework> {\n    if(reset) {\n      this.isInit = false;\n      await this.reset(false);\n    }\n\n    const updatedOptions = {...options};\n    if(this.isInit && this.options.name) {\n      updatedOptions.name = this.options.name;\n    }\n\n    this.options = {...this.defaultOptions, ...updatedOptions};\n    const {debug, middleware, name, stores} = this.options;\n\n    try {\n      await this.useStorage(name ?? 'arkhamjs');\n    } catch(error) {\n      // eslint-disable-next-line no-console\n      console.error('Arkham Error: There was an error while using storage.', name);\n      throw error;\n    }\n\n    if(stores?.length) {\n      try {\n        await this.addStores(stores);\n      } catch(error) {\n        // eslint-disable-next-line no-console\n        console.error('Arkham Error: There was an error while adding stores.', stores);\n        throw error;\n      }\n    }\n\n    if(middleware?.length) {\n      this.addMiddleware(middleware);\n    }\n\n    const windowProperty: string = 'arkhamjs';\n    if(debug) {\n      (window as any)[windowProperty] = this;\n    } else {\n      delete (window as any)[windowProperty];\n    }\n\n    this.isInit = true;\n    this.emit(ArkhamConstants.INIT);\n\n    return this;\n  }\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  offInit(listener: (...args: any[]) => void): void {\n    this.off(ArkhamConstants.INIT, listener);\n  }\n\n  override off(eventType: string, listener: (...args: any[]) => void): this {\n    return this.removeListener(eventType, listener);\n  }\n\n  override on(eventType: string, listener: (...args: any[]) => void): this {\n    return this.addListener(eventType, listener);\n  }\n\n  async addStores(stores: FluxStore[]): Promise<FluxStore[]> {\n    const registeredStores: FluxStore[] = stores.map((store: FluxStore) => this.register(store));\n    const {name, storage} = this.options;\n\n    if(storage?.setStorageData) {\n      try {\n        await storage.setStorageData(name ?? 'arkhamjs', this.state);\n      } catch(error) {\n        throw error;\n      }\n    }\n\n    return registeredStores;\n  }\n\n  removeMiddleware(names: string[]): void {\n    names.forEach((name: string) => {\n      this.pluginTypes.forEach((type: string) => {\n        this.middleware[`${type}List`] = this.removePlugin(type, name);\n      });\n    });\n  }\n\n  async reset(clearStorage: boolean = true): Promise<void> {\n    const {name, storage} = this.options;\n\n    if(storage && clearStorage) {\n      try {\n        await storage.setStorageData?.(name ?? 'arkhamjs', {});\n      } catch(error) {\n        throw error;\n      }\n    }\n\n    this.middleware = {};\n    this.options = {...this.defaultOptions};\n    this.state = {};\n    this.storeActions = {};\n    this.stateCache.clear();\n    this.stateChanged = false;\n    this.isInit = false;\n\n    this.pluginTypes.forEach((type: string) => this.middleware[`${type}List`] = []);\n  }\n\n  setState(path: string | string[] = '', value: unknown): Promise<boolean> {\n    if(path) {\n      this.state = set(this.state, path, cloneDeep(value));\n      this.stateChanged = true;\n\n      const pathKey = Array.isArray(path) ? path.join('.') : path;\n      this.stateCache.delete(pathKey);\n    }\n\n    if(this.options.storage && this.updateStorage) {\n      return this.updateStorage();\n    }\n\n    return Promise.resolve(false);\n  }\n\n  private async processMiddleware(\n    middlewareList: FluxPluginType[],\n    action: FluxAction,\n    appInfo: Record<string, unknown>\n  ): Promise<FluxAction> {\n    return Promise\n      .all(\n        middlewareList.map((plugin: FluxPluginType) =>\n          plugin.method(cloneDeep(action), cloneDeep(this.state), appInfo)\n        )\n      )\n      .then(\n        (actions) => actions.reduce((updatedAction, action) =>\n          merge(updatedAction, action), action) as FluxAction\n      )\n      .catch((error) => {\n        throw error;\n      });\n  }\n\n  private updateStorage: () => Promise<boolean> = () => Promise.resolve(false);\n\n  private updateStoresState(type: string, data: Record<string, unknown>): void {\n    Object.keys(this.storeActions).forEach((storeName: string) => {\n      const storeFn = this.storeActions[storeName];\n      if(storeFn) {\n        const currentState = this.state[storeName] || storeFn.initialState || {};\n\n        const newState = storeFn.action(type, data, currentState);\n        if(newState !== currentState) {\n          this.state[storeName] = cloneDeep(newState) || currentState;\n          this.stateChanged = true;\n        }\n      }\n    });\n  }\n\n  private getCachedStack(): unknown[] {\n    const cacheKey = new Error().stack?.split('\\n')[2] || '';\n\n    if(STACK_CACHE.has(cacheKey)) {\n      return STACK_CACHE.get(cacheKey)!;\n    }\n\n    let stack: unknown[] = [];\n    try {\n      const stackProperty = 'stackTraceLimit';\n      const originalLimit = (Error as any).stackTraceLimit;\n      (Error as any)[stackProperty] = Infinity;\n      stack = parseStack(new Error());\n      (Error as any)[stackProperty] = originalLimit;\n\n      if(STACK_CACHE.size >= STACK_CACHE_SIZE) {\n        const firstKey = STACK_CACHE.keys().next().value;\n        if(firstKey) {\n          STACK_CACHE.delete(firstKey);\n        }\n      }\n      STACK_CACHE.set(cacheKey, stack);\n    } catch(error) {\n    }\n\n    return stack;\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      const exists: boolean = list.some((obj: FluxPluginType) => obj.name === name);\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    this.stateCache.clear(); // Clear cache when stores change\n  }\n\n  private register(store: any): FluxStore {\n    if(!store) {\n      throw Error('Store is undefined. Cannot register with Flux.');\n    }\n\n    let storeName: string;\n    let storeAction: (type: string, data: unknown, state: unknown) => unknown;\n    let initialState: unknown;\n\n    if(typeof store === 'function') {\n      // Function store - extract name from function.name\n      storeName = store.name || 'anonymous';\n      storeAction = store;\n      initialState = store();\n    } else if(typeof store?.action === 'function') {\n      // Object store with action method\n      storeName = store.name || 'anonymous';\n      storeAction = store.action;\n      initialState = store.initialState || store.action();\n    } else {\n      throw Error(`${store} is not a valid store. Must be a function or object with action method.`);\n    }\n\n    if(!storeName || storeName === 'anonymous') {\n      // Silently ignore anonymous stores - return undefined\n      return undefined as any;\n    }\n\n    const fluxStore: FluxStore = {\n      action: storeAction,\n      initialState,\n      name: storeName\n    };\n\n    if(!this.storeActions[storeName]) {\n      this.storeActions[storeName] = fluxStore;\n\n      if(!this.state[storeName]) {\n        this.state[storeName] = cloneDeep(initialState || {});\n      }\n    }\n\n    return this.storeActions[storeName]!;\n  }\n\n  private removePlugin(type: string, name: string): FluxPluginType[] {\n    const list = this.middleware[`${type}List`] || [];\n    return list.filter((obj: FluxPluginType) => obj.name !== name);\n  }\n\n  private async useStorage(name: string): Promise<void> {\n    const {storage, state, storageWait} = this.options;\n\n    if(storage) {\n      try {\n        this.state = state || await storage?.getStorageData?.(name) || {};\n        this.updateStorage = debounceCompact(\n          () => storage?.setStorageData?.(name, this.state),\n          storageWait ?? 300\n        ) as any;\n      } catch(error) {\n        // eslint-disable-next-line no-console\n        console.error(`ArkhamJS Error: Using storage, \"${name}\".`);\n        throw error;\n      }\n    } else {\n      this.state = state || {};\n    }\n  }\n}\n\nexport const Flux: FluxFramework = new FluxFramework();\n"],"names":["cloneDeep","debounceCompact","get","merge","set","parseStack","EventEmitter","ArkhamConstants","STACK_CACHE","Map","STACK_CACHE_SIZE","FluxFramework","addMiddleware","middleware","forEach","middleObj","Error","middleName","name","existingMiddleware","preDispatchList","find","m","postDispatchList","console","warn","pluginTypes","type","method","plugin","addPlugin","clearAppData","Object","keys","storeActions","storeName","storeFn","state","initialState","stateCache","clear","stateChanged","storage","options","setStorageData","Promise","resolve","clearMiddleware","pluginType","removeStores","storeNames","deregister","dispatch","action","silent","startTime","Date","now","clonedAction","stack","debug","getCachedStack","appInfo","duration","length","processMiddleware","data","updateStoresState","updateStorage","error","emit","getOptions","getState","path","defaultValue","pathKey","Array","isArray","join","has","storeValue","value","result","undefined","getStore","init","reset","isInit","updatedOptions","defaultOptions","stores","useStorage","addStores","windowProperty","window","INIT","onInit","listener","on","offInit","off","eventType","removeListener","addListener","registeredStores","map","store","register","removeMiddleware","names","removePlugin","clearStorage","setState","delete","middlewareList","all","then","actions","reduce","updatedAction","catch","currentState","newState","cacheKey","split","stackProperty","originalLimit","stackTraceLimit","Infinity","size","firstKey","next","list","exists","some","obj","push","storeAction","fluxStore","filter","storageWait","getStorageData","routerType","scrollToTop","title","bind","initFlux","Flux"],"mappings":"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"}

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

@@ -49,3 +49,4 @@ export interface FluxPluginType {
 export interface ErrorConstructor {
     captureStackTrace(thisArg: any, func: any): void;
 }
+//# sourceMappingURL=Flux.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Flux.types.d.ts","sourceRoot":"","sources":["../../src/Flux/Flux.types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;IACrD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,GAAG,EAAE,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACzE;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC;CAC5B;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAEhH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;CAC9C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;CAClD"}

package/lib/Flux/Flux.types.js

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constants/ArkhamConstants.d.ts

@@ -10,3 +10,4 @@ export declare class ArkhamConstants {
     static readonly UPDATE_TITLE: string;
     static readonly UPDATE_VIEW: string;
 }
+//# sourceMappingURL=ArkhamConstants.d.ts.map

package/lib/constants/ArkhamConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkhamConstants.d.ts","sourceRoot":"","sources":["../../src/constants/ArkhamConstants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,eAAe;IAC1B,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAoB;IACnD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAuB;IACzD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAiB;IAC7C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAiB;IAC7C,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAyB;IAC7D,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAwB;CAC5D"}

package/lib/constants/ArkhamConstants.js

@@ -0,0 +1,26 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export class ArkhamConstants {
+}
+_define_property(ArkhamConstants, "GO_BACK", 'ARKHAM_GO_BACK');
+_define_property(ArkhamConstants, "GO_REPLACE", 'ARKHAM_GO_REPLACE');
+_define_property(ArkhamConstants, "GOTO", 'ARKHAM_GOTO');
+_define_property(ArkhamConstants, "INIT", 'ARKHAM_INIT');
+_define_property(ArkhamConstants, "UPDATE_TITLE", 'ARKHAM_UPDATE_TITLE');
+_define_property(ArkhamConstants, "UPDATE_VIEW", 'ARKHAM_UPDATE_VIEW');
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2Fya2hhbWpzL3BhY2thZ2VzL2Fya2hhbWpzL3NyYy9jb25zdGFudHMvQXJraGFtQ29uc3RhbnRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE4LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5cbmV4cG9ydCBjbGFzcyBBcmtoYW1Db25zdGFudHMge1xuICBzdGF0aWMgcmVhZG9ubHkgR09fQkFDSzogc3RyaW5nID0gJ0FSS0hBTV9HT19CQUNLJztcbiAgc3RhdGljIHJlYWRvbmx5IEdPX1JFUExBQ0U6IHN0cmluZyA9ICdBUktIQU1fR09fUkVQTEFDRSc7XG4gIHN0YXRpYyByZWFkb25seSBHT1RPOiBzdHJpbmcgPSAnQVJLSEFNX0dPVE8nO1xuICBzdGF0aWMgcmVhZG9ubHkgSU5JVDogc3RyaW5nID0gJ0FSS0hBTV9JTklUJztcbiAgc3RhdGljIHJlYWRvbmx5IFVQREFURV9USVRMRTogc3RyaW5nID0gJ0FSS0hBTV9VUERBVEVfVElUTEUnO1xuICBzdGF0aWMgcmVhZG9ubHkgVVBEQVRFX1ZJRVc6IHN0cmluZyA9ICdBUktIQU1fVVBEQVRFX1ZJRVcnO1xufVxuIl0sIm5hbWVzIjpbIkFya2hhbUNvbnN0YW50cyIsIkdPX0JBQ0siLCJHT19SRVBMQUNFIiwiR09UTyIsIklOSVQiLCJVUERBVEVfVElUTEUiLCJVUERBVEVfVklFVyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQUFBOzs7Q0FHQyxHQUVELE9BQU8sTUFBTUE7QUFPYjtBQU5FLGlCQURXQSxpQkFDS0MsV0FBa0I7QUFDbEMsaUJBRldELGlCQUVLRSxjQUFxQjtBQUNyQyxpQkFIV0YsaUJBR0tHLFFBQWU7QUFDL0IsaUJBSldILGlCQUlLSSxRQUFlO0FBQy9CLGlCQUxXSixpQkFLS0ssZ0JBQXVCO0FBQ3ZDLGlCQU5XTCxpQkFNS00sZUFBc0IifQ==

package/lib/index.d.ts

@@ -6,3 +6,4 @@ import { ArkhamConstants } from './constants/ArkhamConstants.js';
 import { Flux, FluxFramework } from './Flux/Flux.js';
 export * from './Flux/Flux.types.js';
 export { ArkhamConstants, Flux, FluxFramework };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAC,eAAe,EAAC,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAC,IAAI,EAAE,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAEnD,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAC,eAAe,EAAE,IAAI,EAAE,aAAa,EAAC,CAAC"}

package/lib/index.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { ArkhamConstants } from './constants/ArkhamConstants.js';
+import { Flux, FluxFramework } from './Flux/Flux.js';
+export * from './Flux/Flux.types.js';
+export { ArkhamConstants, Flux, FluxFramework };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2Fya2hhbWpzL3BhY2thZ2VzL2Fya2hhbWpzL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtBcmtoYW1Db25zdGFudHN9IGZyb20gJy4vY29uc3RhbnRzL0Fya2hhbUNvbnN0YW50cy5qcyc7XG5pbXBvcnQge0ZsdXgsIEZsdXhGcmFtZXdvcmt9IGZyb20gJy4vRmx1eC9GbHV4LmpzJztcblxuZXhwb3J0ICogZnJvbSAnLi9GbHV4L0ZsdXgudHlwZXMuanMnO1xuZXhwb3J0IHtBcmtoYW1Db25zdGFudHMsIEZsdXgsIEZsdXhGcmFtZXdvcmt9O1xuXG4iXSwibmFtZXMiOlsiQXJraGFtQ29uc3RhbnRzIiwiRmx1eCIsIkZsdXhGcmFtZXdvcmsiXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELFNBQVFBLGVBQWUsUUFBTyxpQ0FBaUM7QUFDL0QsU0FBUUMsSUFBSSxFQUFFQyxhQUFhLFFBQU8saUJBQWlCO0FBRW5ELGNBQWMsdUJBQXVCO0FBQ3JDLFNBQVFGLGVBQWUsRUFBRUMsSUFBSSxFQUFFQyxhQUFhLEdBQUUifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/arkhamjs",
-  "version": "3.31.8",
+  "version": "3.31.9",
   "publishConfig": {
     "access": "public"
   },
@@ -69,7 +69,7 @@
     "update": "lex update --interactive"
   },
   "dependencies": {
-    "@nlabs/utils": "2.8.4",
+    "@nlabs/utils": "2.8.6",
     "events": "^3.3.0"
   },
   "files": [