@nlabs/arkhamjs 3.31.7 → 3.31.9

package/lib/Flux/Flux.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import type { FluxAction, FluxMiddlewareType, FluxOptions, FluxStore } from './Flux.types';
+import type { FluxAction, FluxMiddlewareType, FluxOptions, FluxStore } from './Flux.types.js';
 export declare class FluxFramework extends EventEmitter {
     static initFlux: boolean;
     isInit: boolean;
@@ -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

@@ -1,5 +1,410 @@
-/* ArkhamJS - Optimized Build */
-var y=Object.defineProperty;var S=(c,h,t)=>h in c?y(c,h,{enumerable:!0,configurable:!0,writable:!0,value:t}):c[h]=t;var n=(c,h,t)=>S(c,typeof h!="symbol"?h+"":h,t);import{cloneDeep as l,debounceCompact as x,get as v,merge as F,parseStack as k,set as A}from"@nlabs/utils";import{EventEmitter as T}from"events";import{ArkhamConstants as g}from"../constants/ArkhamConstants";const u=new Map,b=100;class f extends T{constructor(){super();n(this,"isInit",!1);n(this,"pluginTypes",["preDispatch","postDispatch"]);n(this,"state",{});n(this,"storeActions",{});n(this,"defaultOptions",{name:"arkhamjs",routerType:"browser",scrollToTop:!0,storageWait:300,stores:[],title:"ArkhamJS"});n(this,"middleware",{});n(this,"options",this.defaultOptions);n(this,"stateCache",new Map);n(this,"stateChanged",!1);n(this,"updateStorage",()=>Promise.resolve(!1));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(t=>this.middleware[`${t}List`]=[])}addMiddleware(t){t.forEach(e=>{if(!e||typeof e!="function"&&typeof e!="object")throw Error("Unknown middleware is not configured properly. Cannot add to Flux.");const s=e.name||"";if(!s)throw Error("Unknown middleware is not configured properly. Requires name property. Cannot add to Flux.");this.middleware.preDispatchList?.find(r=>r.name===s)||this.middleware.postDispatchList?.find(r=>r.name===s)||this.pluginTypes.forEach(r=>{const a=e[r];if(a&&typeof a=="function"){const o={method:a,name:s};this.middleware[`${r}List`]=this.addPlugin(r,o)}})})}clearAppData(){Object.keys(this.storeActions).forEach(s=>{const i=this.storeActions[s];i&&(this.state[i.name]=i.initialState)}),this.stateCache.clear(),this.stateChanged=!0;const{name:t,storage:e}=this.options;return e?.setStorageData?e.setStorageData(t??"arkhamjs",this.state):Promise.resolve(!0)}clearMiddleware(){return Object.keys(this.middleware).forEach(t=>{this.middleware[t]=[]}),!0}removeStores(t){t.forEach(e=>this.deregister(e))}async dispatch(t,e=!1){if(!t)throw new Error("ArkhamJS Error: Flux.dispatch requires an action.");const s=Date.now();let i=l(t),r=[];this.options.debug&&(r=this.getCachedStack());const a={duration:0,options:this.options,stack:r},{postDispatchList:o=[],preDispatchList:p=[]}=this.middleware;p.length&&(i=await this.processMiddleware(p,i,a));const{type:d,...m}=i;if(!d||d==="")return Promise.resolve(i);if(this.updateStoresState(d,m),this.stateChanged&&this.options.storage&&this.updateStorage)try{await this.updateStorage(),this.stateChanged=!1}catch{}const w=Date.now()-s;return a.duration=w,o.length&&(i=await this.processMiddleware(o,i,a)),e||(this.emit(d,i),this.emit("arkhamjs",this.state)),Promise.resolve(i)}getOptions(){return this.options}getState(t="",e){const s=Array.isArray(t)?t.join("."):t;if(this.stateCache.has(s))return this.stateCache.get(s);let i;t?i=v(this.state,t):i=this.state||{};const r=i&&l(i),a=r===void 0?e:r;return this.stateCache.set(s,a),a}getStore(t=""){return this.storeActions[t]}async init(t={},e=!1){e&&(this.isInit=!1,await this.reset(!1));const s={...t};this.isInit&&this.options.name&&(s.name=this.options.name),this.options={...this.defaultOptions,...s};const{debug:i,middleware:r,name:a,stores:o}=this.options;try{await this.useStorage(a??"arkhamjs")}catch(d){throw d}if(o?.length)try{await this.addStores(o)}catch(d){throw d}r?.length&&this.addMiddleware(r);const p="arkhamjs";return i?window[p]=this:delete window[p],this.isInit=!0,this.emit(g.INIT),this}onInit(t){this.on(g.INIT,t),this.isInit&&t()}offInit(t){this.off(g.INIT,t)}off(t,e){return this.removeListener(t,e)}on(t,e){return this.addListener(t,e)}async addStores(t){const e=t.map(r=>this.register(r)),{name:s,storage:i}=this.options;if(i?.setStorageData)try{await i.setStorageData(s??"arkhamjs",this.state)}catch(r){throw r}return e}removeMiddleware(t){t.forEach(e=>{this.pluginTypes.forEach(s=>{this.middleware[`${s}List`]=this.removePlugin(s,e)})})}async reset(t=!0){const{name:e,storage:s}=this.options;if(s&&t)try{await s.setStorageData?.(e??"arkhamjs",{})}catch(i){throw i}this.middleware={},this.options={...this.defaultOptions},this.state={},this.storeActions={},this.stateCache.clear(),this.stateChanged=!1,this.isInit=!1,this.pluginTypes.forEach(i=>this.middleware[`${i}List`]=[])}setState(t="",e){if(t){this.state=A(this.state,t,l(e)),this.stateChanged=!0;const s=Array.isArray(t)?t.join("."):t;this.stateCache.delete(s)}return this.options.storage&&this.updateStorage?this.updateStorage():Promise.resolve(!1)}async processMiddleware(t,e,s){return Promise.all(t.map(i=>i.method(l(e),l(this.state),s))).then(i=>i.reduce((r,a)=>F(r,a),e)).catch(i=>{throw i})}updateStoresState(t,e){Object.keys(this.storeActions).forEach(s=>{const i=this.storeActions[s];if(i){const r=this.state[s]||i.initialState||{},a=i.action(t,e,r);a!==r&&(this.state[s]=l(a)||r,this.stateChanged=!0)}})}getCachedStack(){const t=new Error().stack?.split(`
-`)[2]||"";if(u.has(t))return u.get(t);let e=[];try{const s="stackTraceLimit",i=Error.stackTraceLimit;if(Error[s]=1/0,e=k(new Error),Error[s]=i,u.size>=b){const r=u.keys().next().value;r&&u.delete(r)}u.set(t,e)}catch{}return e}addPlugin(t,e){const s=this.middleware[`${t}List`]||[],{method:i,name:r}=e;if(i&&typeof i=="function")s.some(o=>o.name===r)||s.push({method:i,name:r});else if(i!==void 0)throw Error(`${e.name} middleware is not configured properly. Method is not a function.`);return s}deregister(t=""){delete this.storeActions[t],delete this.state[t],this.stateCache.clear()}register(t){if(!t)throw Error("Store is undefined. Cannot register with Flux.");let e,s,i;if(typeof t=="function")e=t.name||"anonymous",s=t,i=t();else if(typeof t?.action=="function")e=t.name||"anonymous",s=t.action,i=t.initialState||t.action();else throw Error(`${t} is not a valid store. Must be a function or object with action method.`);if(!e||e==="anonymous")return;const r={action:s,initialState:i,name:e};return this.storeActions[e]||(this.storeActions[e]=r,this.state[e]||(this.state[e]=l(i||{}))),this.storeActions[e]}removePlugin(t,e){return(this.middleware[`${t}List`]||[]).filter(i=>i.name!==e)}async useStorage(t){const{storage:e,state:s,storageWait:i}=this.options;if(e)try{this.state=s||await e?.getStorageData?.(t)||{},this.updateStorage=x(()=>e?.setStorageData?.(t,this.state),i??300)}catch(r){throw r}else this.state=s||{}}}n(f,"initFlux",!1);const I=new f;export{I as Flux,f as FluxFramework};
-/* End ArkhamJS */
-//# 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 {cloneDeep, debounceCompact, get, merge, parseStack, set} from '@nlabs/utils';\nimport {EventEmitter} from 'events';\n\nimport {ArkhamConstants} from '../constants/ArkhamConstants';\n\nimport type {FluxAction, FluxMiddlewareType, FluxOptions, FluxPluginType, FluxStore} from './Flux.types';\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"],
  "mappings": "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",
  "names": ["cloneDeep", "debounceCompact", "get", "merge", "parseStack", "set", "EventEmitter", "ArkhamConstants", "STACK_CACHE", "STACK_CACHE_SIZE", "FluxFramework", "EventEmitter", "__publicField", "type", "middleware", "middleObj", "middleName", "m", "method", "plugin", "storeName", "storeFn", "name", "storage", "pluginType", "storeNames", "action", "silent", "startTime", "clonedAction", "cloneDeep", "stack", "appInfo", "postDispatchList", "preDispatchList", "data", "duration", "path", "defaultValue", "pathKey", "storeValue", "get", "value", "result", "options", "reset", "updatedOptions", "debug", "stores", "error", "windowProperty", "ArkhamConstants", "listener", "eventType", "registeredStores", "store", "names", "clearStorage", "set", "middlewareList", "actions", "updatedAction", "merge", "currentState", "newState", "cacheKey", "stackProperty", "originalLimit", "parseStack", "firstKey", "list", "obj", "storeAction", "initialState", "fluxStore", "state", "storageWait", "debounceCompact", "Flux"]
}

+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

@@ -1,3 +1,6 @@
-/* ArkhamJS - Optimized Build */
-/* End ArkhamJS */
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K
+/**
+ * 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

@@ -1,4 +1,26 @@
-/* ArkhamJS - Optimized Build */
-var t=Object.defineProperty;var r=(i,A,T)=>A in i?t(i,A,{enumerable:!0,configurable:!0,writable:!0,value:T}):i[A]=T;var _=(i,A,T)=>r(i,typeof A!="symbol"?A+"":A,T);class E{}_(E,"GO_BACK","ARKHAM_GO_BACK"),_(E,"GO_REPLACE","ARKHAM_GO_REPLACE"),_(E,"GOTO","ARKHAM_GOTO"),_(E,"INIT","ARKHAM_INIT"),_(E,"UPDATE_TITLE","ARKHAM_UPDATE_TITLE"),_(E,"UPDATE_VIEW","ARKHAM_UPDATE_VIEW");export{E as ArkhamConstants};
-/* End ArkhamJS */
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2NvbnN0YW50cy9BcmtoYW1Db25zdGFudHMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE4LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5cbmV4cG9ydCBjbGFzcyBBcmtoYW1Db25zdGFudHMge1xuICBzdGF0aWMgcmVhZG9ubHkgR09fQkFDSzogc3RyaW5nID0gJ0FSS0hBTV9HT19CQUNLJztcbiAgc3RhdGljIHJlYWRvbmx5IEdPX1JFUExBQ0U6IHN0cmluZyA9ICdBUktIQU1fR09fUkVQTEFDRSc7XG4gIHN0YXRpYyByZWFkb25seSBHT1RPOiBzdHJpbmcgPSAnQVJLSEFNX0dPVE8nO1xuICBzdGF0aWMgcmVhZG9ubHkgSU5JVDogc3RyaW5nID0gJ0FSS0hBTV9JTklUJztcbiAgc3RhdGljIHJlYWRvbmx5IFVQREFURV9USVRMRTogc3RyaW5nID0gJ0FSS0hBTV9VUERBVEVfVElUTEUnO1xuICBzdGF0aWMgcmVhZG9ubHkgVVBEQVRFX1ZJRVc6IHN0cmluZyA9ICdBUktIQU1fVVBEQVRFX1ZJRVcnO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjtvS0FLTyxNQUFNQSxDQUFnQixDQU83QixDQU5FQyxFQURXRCxFQUNLLFVBQWtCLGtCQUNsQ0MsRUFGV0QsRUFFSyxhQUFxQixxQkFDckNDLEVBSFdELEVBR0ssT0FBZSxlQUMvQkMsRUFKV0QsRUFJSyxPQUFlLGVBQy9CQyxFQUxXRCxFQUtLLGVBQXVCLHVCQUN2Q0MsRUFOV0QsRUFNSyxjQUFzQiIsCiAgIm5hbWVzIjogWyJBcmtoYW1Db25zdGFudHMiLCAiX19wdWJsaWNGaWVsZCJdCn0K
+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

@@ -2,7 +2,8 @@
  * 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';
-import { Flux, FluxFramework } from './Flux/Flux';
-export * from './Flux/Flux.types';
+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

@@ -1,4 +1,9 @@
-/* ArkhamJS - Optimized Build */
-import{ArkhamConstants as o}from"./constants/ArkhamConstants";import{Flux as t,FluxFramework as p}from"./Flux/Flux";export*from"./Flux/Flux.types";export{o as ArkhamConstants,t as Flux,p as FluxFramework};
-/* End ArkhamJS */
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtBcmtoYW1Db25zdGFudHN9IGZyb20gJy4vY29uc3RhbnRzL0Fya2hhbUNvbnN0YW50cyc7XG5pbXBvcnQge0ZsdXgsIEZsdXhGcmFtZXdvcmt9IGZyb20gJy4vRmx1eC9GbHV4JztcblxuZXhwb3J0ICogZnJvbSAnLi9GbHV4L0ZsdXgudHlwZXMnO1xuZXhwb3J0IHtBcmtoYW1Db25zdGFudHMsIEZsdXgsIEZsdXhGcmFtZXdvcmt9O1xuIl0sCiAgIm1hcHBpbmdzIjogIjtBQUlBLE9BQVEsbUJBQUFBLE1BQXNCLDhCQUM5QixPQUFRLFFBQUFDLEVBQU0saUJBQUFDLE1BQW9CLGNBRWxDLFdBQWMiLAogICJuYW1lcyI6IFsiQXJraGFtQ29uc3RhbnRzIiwgIkZsdXgiLCAiRmx1eEZyYW1ld29yayJdCn0K
+/**
+ * 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.7",
+  "version": "3.31.9",
   "publishConfig": {
     "access": "public"
   },
@@ -69,7 +69,7 @@
     "update": "lex update --interactive"
   },
   "dependencies": {
-    "@nlabs/utils": "2.8.3",
+    "@nlabs/utils": "2.8.6",
     "events": "^3.3.0"
   },
   "files": [