valyrian.js 7.2.12 → 8.0.1

package/README.md

@@ -36,9 +36,9 @@ Lightweight steel to forge PWAs. (Minimal Frontend Framework with server side re
 
 ## Table of Contents
 
-*   [Tests](#tests)
-*   [Contributing](#contributing)
-*   [Legal](#legal)
+* [Tests](#tests)
+* [Contributing](#contributing)
+* [Legal](#legal)
 
 ## Tests
 
@@ -48,9 +48,9 @@ For development use `yarn dev:test`
 
 ## Contributing
 
-*   Use prettify and eslint to lint your code.
-*   Add tests for any new or changed functionality.
-*   Update the readme with an example if you add or change any functionality.
+* Use prettify and eslint to lint your code.
+* Add tests for any new or changed functionality.
+* Update the readme with an example if you add or change any functionality.
 
 ## Legal
 

package/dist/flux-store/index.d.ts

@@ -0,0 +1,32 @@
+interface StoreOptions {
+    state?: Record<string, any> | (() => Record<string, any>);
+    mutations?: Record<string, (state: Record<string, any>, ...args: any[]) => void>;
+    actions?: Record<string, (store: FluxStore, ...args: any[]) => any>;
+    getters?: Record<string, (state: Record<string, any>, getters: Record<string, any>, globalState?: any, globalGetters?: any) => any>;
+    modules?: Record<string, StoreOptions>;
+    shouldFreeze?: boolean;
+    namespace?: string;
+    rootStore?: FluxStore;
+}
+export declare class FluxStore {
+    state: Record<string, any>;
+    getters: Record<string, any>;
+    private init;
+    rootStore: FluxStore | null;
+    namespace: string | null;
+    constructor({ state, mutations, actions, getters, modules, shouldFreeze, namespace, rootStore }?: StoreOptions);
+    private keyExists;
+    private isFunction;
+    private getStore;
+    private isUnfrozen;
+    commit(mutation: string, ...args: any[]): void;
+    dispatch(action: string, ...args: any[]): Promise<any>;
+    trigger(event: string, ...args: any[]): void;
+    on(event: string, listener: Function, namespace?: string): () => void;
+    off(event: string, listener: Function): void;
+    use(plugin: Function, ...options: any[]): void;
+    registerModule(namespace: string, module: StoreOptions): void;
+    unregisterModule(namespace: string): void;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/flux-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/flux-store/index.ts"],"names":[],"mappings":"AAGA,UAAU,YAAY;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAE1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC,CAAC;IAEjF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAC;IACpE,OAAO,CAAC,EAAE,MAAM,CACd,MAAM,EAEN,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,EAAE,GAAG,KAAK,GAAG,CAC1G,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAGD,qBAAa,SAAS;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpC,OAAO,CAAC,IAAI,CAUV;IAEK,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;gBAGpB,EACV,KAAU,EACV,SAAc,EACd,OAAY,EACZ,OAAY,EACZ,OAAY,EACZ,YAAmB,EACnB,SAAS,EACT,SAAS,EACV,GAAE,YAAiB;IAsHpB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,UAAU;IAOX,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAcjC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IAc5D,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAKrC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM;IAsBxD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAWrC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE;IAUvC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY;IAiBtD,gBAAgB,CAAC,SAAS,EAAE,MAAM;CAe1C"}

package/dist/flux-store/index.js

@@ -0,0 +1,267 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/flux-store/index.ts
+var flux_store_exports = {};
+__export(flux_store_exports, {
+  FluxStore: () => FluxStore
+});
+module.exports = __toCommonJS(flux_store_exports);
+var import_valyrian = require("valyrian.js");
+var import_utils = require("valyrian.js/utils");
+var FluxStore = class _FluxStore {
+  state;
+  getters;
+  init;
+  // eslint-disable-next-line no-use-before-define
+  rootStore;
+  namespace;
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  constructor({
+    state = {},
+    mutations = {},
+    actions = {},
+    getters = {},
+    modules = {},
+    shouldFreeze = true,
+    namespace,
+    rootStore
+  } = {}) {
+    const localState = typeof state === "function" ? state() : state;
+    this.state = new Proxy(localState || {}, {
+      // Every time we try to access a property from the state we try to deep freeze the property
+      // to prevent direct modifications to the state
+      get: (state2, prop) => {
+        if ((this.rootStore || this).init.modules[prop]) {
+          return state2[prop];
+        }
+        if (shouldFreeze) {
+          if (this.init.frozen) {
+            return (0, import_utils.deepFreeze)(state2[prop]);
+          }
+          const newState = (0, import_utils.deepCloneUnfreeze)(state2);
+          for (const key of Reflect.ownKeys(newState)) {
+            localState[key] = newState[key];
+          }
+        }
+        return state2[prop];
+      },
+      // If the user tries to set directly it will throw an error, only if we have unfrozen the state via commit
+      // this will proceed to set the value
+      set: (state2, prop, value) => {
+        this.isUnfrozen();
+        const old = state2[prop];
+        state2[prop] = value;
+        if (this.namespace) {
+          prop = `${this.namespace}.${prop}`;
+        }
+        (this.rootStore || this).trigger("set", prop, value, old);
+        return true;
+      },
+      // If the user tries to delete directly it will throw an error, only if we have unfrozen the state via commit
+      // this will proceed to delete the property
+      deleteProperty: (state2, prop) => {
+        this.isUnfrozen();
+        const old = state2[prop];
+        Reflect.deleteProperty(state2, prop);
+        if (this.namespace) {
+          prop = `${this.namespace}.${prop}`;
+        }
+        (this.rootStore || this).trigger("delete", prop, old);
+        return true;
+      }
+    });
+    this.rootStore = rootStore || null;
+    this.namespace = namespace || null;
+    this.init = {
+      frozen: true,
+      plugins: [],
+      modules: {},
+      childModuleNamespaces: Object.keys(modules || {}),
+      listeners: {
+        set: [],
+        delete: [],
+        beforecommit: [],
+        commit: [],
+        beforedispatch: [],
+        dispatch: [],
+        getter: [],
+        addlistener: [],
+        removelistener: [],
+        plugin: [],
+        registerModule: [],
+        unregisterModule: []
+      },
+      getters: getters || {},
+      mutations: mutations || {},
+      actions: actions || {}
+    };
+    this.getters = new Proxy(getters || {}, {
+      // When we try to get a property of the getter we will call the original
+      // getter method passing the state as first argument and the other getters as second
+      // if we try to get a non existent getter it will fail silently as if
+      // we were trying to get an undefined property
+      get: (getters2, getter) => {
+        try {
+          const { store, key } = this.getStore(this, getter);
+          if (store instanceof _FluxStore && store.init.getters[key]) {
+            const value = store.init.getters[key](store.state, store.getters, this.state, this.getters);
+            if (this.namespace) {
+              getter = `${this.namespace}.${getter}`;
+            }
+            (this.rootStore || this).trigger("getter", getter, value);
+            return value;
+          }
+        } catch (error) {
+          return;
+        }
+      }
+    });
+    if (modules) {
+      Object.keys(modules).forEach((namespace2) => {
+        const n = this.namespace ? `${this.namespace}.${namespace2}` : namespace2;
+        (this.rootStore || this).registerModule(n, modules[namespace2]);
+      });
+    }
+  }
+  keyExists(objectname, object, key) {
+    if (!object[key]) {
+      throw new Error(`The ${objectname} "${key}" does not exists.`);
+    }
+  }
+  isFunction(type, callback) {
+    if (typeof callback !== "function") {
+      throw new Error(`You need to provide a valid function as ${type}.`);
+    }
+  }
+  // Giving a dot based namespace this method will be used to find the module to be called
+  getStore(store, namespace) {
+    let key = namespace;
+    if (key.indexOf(".") > -1) {
+      const parts = key.split(".");
+      key = parts.pop();
+      const moduleName = parts.join(".");
+      this.keyExists("module", store.init.modules, moduleName);
+      store = store.init.modules[moduleName];
+    }
+    return {
+      store,
+      key
+    };
+  }
+  isUnfrozen() {
+    if (this.init.frozen) {
+      throw new Error("You need to commit a mutation to change the state");
+    }
+  }
+  // This method unfroze the state and process a mutation
+  commit(mutation, ...args) {
+    const { store, key } = this.getStore(this, mutation);
+    this.keyExists("mutation", store.init.mutations, key);
+    store.init.frozen = false;
+    this.trigger("beforecommit", mutation, ...args);
+    store.init.mutations[key](store.state, ...args);
+    this.trigger("commit", mutation, ...args);
+    store.init.frozen = true;
+    (0, import_valyrian.debouncedUpdate)();
+  }
+  // This method will dispatch an action
+  async dispatch(action, ...args) {
+    const { store, key } = this.getStore(this, action);
+    this.keyExists("action", store.init.actions, key);
+    this.trigger("beforedispatch", action, ...args);
+    try {
+      const result = await store.init.actions[key](store, ...args);
+      this.trigger("dispatch", action, ...args);
+      return result;
+    } finally {
+      (0, import_valyrian.debouncedUpdate)();
+    }
+  }
+  // This method will trigger an event
+  trigger(event, ...args) {
+    this.init.listeners[event].forEach((callback) => callback(this, ...args));
+  }
+  // This method will add a listener to the store
+  on(event, listener, namespace) {
+    this.isFunction("listener", listener);
+    if (namespace) {
+      const { store, key } = this.getStore(this, namespace);
+      this.keyExists("event", store.init.listeners, event);
+      if (store.init.listeners[event].indexOf(listener) === -1) {
+        store.init.listeners[event].push(listener);
+        this.trigger("addlistener", event, listener);
+      }
+      return () => this.off(event, listener);
+    }
+    this.keyExists("event", this.init.listeners, event);
+    if (this.init.listeners[event].indexOf(listener) === -1) {
+      this.init.listeners[event].push(listener);
+      this.trigger("addlistener", event, listener);
+    }
+    return () => this.off(event, listener);
+  }
+  // Remove a listener from the store
+  off(event, listener) {
+    this.isFunction("listener", listener);
+    this.keyExists("event", this.init.listeners, event);
+    const index = this.init.listeners[event].indexOf(listener);
+    if (index > -1) {
+      this.init.listeners[event].splice(index, 1);
+      this.trigger("removelistener", event, listener);
+    }
+  }
+  // This method will add a plugin to the store
+  use(plugin, ...options) {
+    this.isFunction("plugin", plugin);
+    if (this.init.plugins.indexOf(plugin) === -1) {
+      plugin(this, ...options);
+      this.init.plugins.push(plugin);
+      this.trigger("plugin", plugin, ...options);
+    }
+  }
+  // This method will register a module to the store
+  registerModule(namespace, module2) {
+    const rootStore = this;
+    if (rootStore.init.modules[namespace]) {
+      throw new Error(`A module with the namespace "${namespace}" is already registered.`);
+    }
+    const newStore = new _FluxStore({ ...module2, rootStore, namespace });
+    rootStore.init.frozen = false;
+    rootStore.init.modules[namespace] = newStore;
+    rootStore.state[namespace] = newStore.state;
+    rootStore.init.frozen = true;
+    rootStore.trigger("registerModule", namespace, module2, newStore);
+    (0, import_valyrian.debouncedUpdate)();
+  }
+  // This method will unregister a module from the store
+  unregisterModule(namespace) {
+    const rootStore = this;
+    const store = rootStore.init.modules[namespace];
+    if (store) {
+      store.init.childModuleNamespaces.forEach((n) => rootStore.unregisterModule(`${namespace}.${n}`));
+      rootStore.init.frozen = false;
+      Reflect.deleteProperty(rootStore.init.modules, namespace);
+      Reflect.deleteProperty(rootStore.state, namespace);
+      rootStore.init.frozen = true;
+      rootStore.trigger("unregisterModule", namespace, store);
+      (0, import_valyrian.debouncedUpdate)();
+    }
+  }
+};

package/dist/flux-store/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../lib/flux-store/index.ts"],
+  "sourcesContent": ["import { debouncedUpdate } from \"valyrian.js\";\nimport { deepCloneUnfreeze, deepFreeze } from \"valyrian.js/utils\";\n\ninterface StoreOptions {\n  state?: Record<string, any> | (() => Record<string, any>);\n  // eslint-disable-next-line no-unused-vars\n  mutations?: Record<string, (state: Record<string, any>, ...args: any[]) => void>;\n  // eslint-disable-next-line no-unused-vars, no-use-before-define\n  actions?: Record<string, (store: FluxStore, ...args: any[]) => any>;\n  getters?: Record<\n    string,\n    // eslint-disable-next-line no-unused-vars\n    (state: Record<string, any>, getters: Record<string, any>, globalState?: any, globalGetters?: any) => any\n  >;\n  modules?: Record<string, StoreOptions>;\n  shouldFreeze?: boolean;\n  namespace?: string;\n  // eslint-disable-next-line no-use-before-define\n  rootStore?: FluxStore;\n}\n\n// This is the store entity\nexport class FluxStore {\n  public state: Record<string, any>;\n  public getters: Record<string, any>;\n  private init: {\n    frozen: boolean;\n    plugins: Function[];\n    // eslint-disable-next-line no-use-before-define\n    modules: Record<string, FluxStore>;\n    childModuleNamespaces: string[];\n    listeners: Record<string, Function[]>;\n    getters: StoreOptions[\"getters\"];\n    mutations: StoreOptions[\"mutations\"];\n    actions: StoreOptions[\"actions\"];\n  };\n  // eslint-disable-next-line no-use-before-define\n  public rootStore: FluxStore | null;\n  public namespace: string | null;\n\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n  constructor({\n    state = {},\n    mutations = {},\n    actions = {},\n    getters = {},\n    modules = {},\n    shouldFreeze = true,\n    namespace,\n    rootStore\n  }: StoreOptions = {}) {\n    // Initialize the localState for this store\n    const localState = typeof state === \"function\" ? state() : state;\n\n    // We create a proxy for the state\n    this.state = new Proxy(localState || {}, {\n      // Every time we try to access a property from the state we try to deep freeze the property\n      // to prevent direct modifications to the state\n      get: (state, prop: string) => {\n        if ((this.rootStore || this).init.modules[prop]) {\n          return state[prop];\n        }\n        if (shouldFreeze) {\n          // We are accessing a property from outside the store\n          if (this.init.frozen) {\n            return deepFreeze(state[prop]);\n          }\n\n          // We are accessing a property from inside the store\n          // So we need to unfreeze the state\n          const newState = deepCloneUnfreeze(state);\n          for (const key of Reflect.ownKeys(newState)) {\n            localState[key] = newState[key];\n          }\n        }\n        return state[prop];\n      },\n      // If the user tries to set directly it will throw an error, only if we have unfrozen the state via commit\n      // this will proceed to set the value\n      set: (state, prop: string, value: any) => {\n        this.isUnfrozen();\n        const old = state[prop];\n        state[prop] = value;\n        if (this.namespace) {\n          prop = `${this.namespace}.${prop}`;\n        }\n        (this.rootStore || this).trigger(\"set\", prop, value, old);\n        return true;\n      },\n      // If the user tries to delete directly it will throw an error, only if we have unfrozen the state via commit\n      // this will proceed to delete the property\n      deleteProperty: (state, prop: string) => {\n        this.isUnfrozen();\n        const old = state[prop];\n        Reflect.deleteProperty(state, prop);\n        if (this.namespace) {\n          prop = `${this.namespace}.${prop}`;\n        }\n        (this.rootStore || this).trigger(\"delete\", prop, old);\n        return true;\n      }\n    });\n\n    // If this is a store been attached to another store\n    // this will have the rootStore for future reference\n    this.rootStore = rootStore || null;\n\n    // If this is a store been attached to another store\n    // this will have the namespace attached\n    this.namespace = namespace || null;\n\n    // We initialize the store with the initial values\n    this.init = {\n      frozen: true,\n      plugins: [],\n      modules: {},\n      childModuleNamespaces: Object.keys(modules || {}),\n      listeners: {\n        set: [],\n        delete: [],\n        beforecommit: [],\n        commit: [],\n        beforedispatch: [],\n        dispatch: [],\n        getter: [],\n        addlistener: [],\n        removelistener: [],\n        plugin: [],\n        registerModule: [],\n        unregisterModule: []\n      },\n      getters: getters || {},\n      mutations: mutations || {},\n      actions: actions || {}\n    };\n\n    // We create a proxy for the getters\n    this.getters = new Proxy(getters || {}, {\n      // When we try to get a property of the getter we will call the original\n      // getter method passing the state as first argument and the other getters as second\n      // if we try to get a non existent getter it will fail silently as if\n      // we were trying to get an undefined property\n      get: (getters, getter: string) => {\n        try {\n          const { store, key } = this.getStore(this, getter);\n          if (store instanceof FluxStore && store.init.getters![key]) {\n            const value = store.init.getters![key](store.state, store.getters, this.state, this.getters);\n            if (this.namespace) {\n              getter = `${this.namespace}.${getter}`;\n            }\n            (this.rootStore || this).trigger(\"getter\", getter, value);\n            return value;\n          }\n        } catch (error) {\n          return;\n        }\n      }\n    });\n\n    // Finally we attach the initial modules\n    if (modules) {\n      Object.keys(modules).forEach((namespace) => {\n        const n = this.namespace ? `${this.namespace}.${namespace}` : namespace;\n        (this.rootStore || this).registerModule(n, modules[namespace]);\n      });\n    }\n  }\n\n  private keyExists(objectname: string, object: Record<string, any>, key: string) {\n    if (!object[key]) {\n      throw new Error(`The ${objectname} \"${key}\" does not exists.`);\n    }\n  }\n\n  private isFunction(type: string, callback: Function) {\n    if (typeof callback !== \"function\") {\n      throw new Error(`You need to provide a valid function as ${type}.`);\n    }\n  }\n\n  // Giving a dot based namespace this method will be used to find the module to be called\n  private getStore(store: FluxStore, namespace: string) {\n    let key = namespace;\n    if (key.indexOf(\".\") > -1) {\n      const parts = key.split(\".\");\n      key = parts.pop()!;\n      const moduleName = parts.join(\".\");\n      this.keyExists(\"module\", store.init.modules, moduleName);\n      store = store.init.modules[moduleName];\n    }\n    return {\n      store,\n      key\n    };\n  }\n\n  private isUnfrozen() {\n    if (this.init.frozen) {\n      throw new Error(\"You need to commit a mutation to change the state\");\n    }\n  }\n\n  // This method unfroze the state and process a mutation\n  public commit(mutation: string, ...args: any[]) {\n    const { store, key } = this.getStore(this, mutation);\n    this.keyExists(\"mutation\", store.init.mutations!, key);\n    store.init.frozen = false;\n    this.trigger(\"beforecommit\", mutation, ...args);\n    store.init.mutations![key](store.state, ...args);\n    this.trigger(\"commit\", mutation, ...args);\n    store.init.frozen = true;\n\n    // We call the debounced update to notify the changes\n    debouncedUpdate();\n  }\n\n  // This method will dispatch an action\n  public async dispatch(action: string, ...args: any[]): Promise<any> {\n    const { store, key } = this.getStore(this, action);\n    this.keyExists(\"action\", store.init.actions!, key);\n    this.trigger(\"beforedispatch\", action, ...args);\n    try {\n      const result = await store.init.actions![key](store, ...args);\n      this.trigger(\"dispatch\", action, ...args);\n      return result;\n    } finally {\n      debouncedUpdate();\n    }\n  }\n\n  // This method will trigger an event\n  public trigger(event: string, ...args: any[]) {\n    this.init.listeners[event].forEach((callback) => callback(this, ...args));\n  }\n\n  // This method will add a listener to the store\n  public on(event: string, listener: Function, namespace?: string) {\n    this.isFunction(\"listener\", listener);\n\n    if (namespace) {\n      const { store, key } = this.getStore(this, namespace);\n      this.keyExists(\"event\", store.init.listeners, event);\n      if (store.init.listeners[event].indexOf(listener) === -1) {\n        store.init.listeners[event].push(listener);\n        this.trigger(\"addlistener\", event, listener);\n      }\n      return () => this.off(event, listener);\n    }\n\n    this.keyExists(\"event\", this.init.listeners, event);\n    if (this.init.listeners[event].indexOf(listener) === -1) {\n      this.init.listeners[event].push(listener);\n      this.trigger(\"addlistener\", event, listener);\n    }\n    return () => this.off(event, listener);\n  }\n\n  // Remove a listener from the store\n  public off(event: string, listener: Function) {\n    this.isFunction(\"listener\", listener);\n    this.keyExists(\"event\", this.init.listeners, event);\n    const index = this.init.listeners[event].indexOf(listener);\n    if (index > -1) {\n      this.init.listeners[event].splice(index, 1);\n      this.trigger(\"removelistener\", event, listener);\n    }\n  }\n\n  // This method will add a plugin to the store\n  public use(plugin: Function, ...options: any[]) {\n    this.isFunction(\"plugin\", plugin);\n    if (this.init.plugins.indexOf(plugin) === -1) {\n      plugin(this, ...options);\n      this.init.plugins.push(plugin);\n      this.trigger(\"plugin\", plugin, ...options);\n    }\n  }\n\n  // This method will register a module to the store\n  public registerModule(namespace: string, module: StoreOptions) {\n    const rootStore = this;\n    if (rootStore.init.modules[namespace]) {\n      throw new Error(`A module with the namespace \"${namespace}\" is already registered.`);\n    }\n    const newStore = new FluxStore({ ...module, rootStore, namespace });\n    rootStore.init.frozen = false;\n    rootStore.init.modules[namespace] = newStore;\n    rootStore.state[namespace] = newStore.state;\n    rootStore.init.frozen = true;\n    rootStore.trigger(\"registerModule\", namespace, module, newStore);\n\n    // We call the debounced update to notify the changes\n    debouncedUpdate();\n  }\n\n  // This method will unregister a module from the store\n  public unregisterModule(namespace: string) {\n    const rootStore = this;\n    const store = rootStore.init.modules[namespace];\n    if (store) {\n      store.init.childModuleNamespaces.forEach((n) => rootStore.unregisterModule(`${namespace}.${n}`));\n      rootStore.init.frozen = false;\n      Reflect.deleteProperty(rootStore.init.modules, namespace);\n      Reflect.deleteProperty(rootStore.state, namespace);\n      rootStore.init.frozen = true;\n      rootStore.trigger(\"unregisterModule\", namespace, store);\n\n      // We call the debounced update to notify the changes\n      debouncedUpdate();\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["state", "getters", "namespace", "module"]
+}

package/dist/flux-store/index.min.js

@@ -0,0 +1 @@
+(()=>{"use strict";var e=Object.defineProperty,t=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,s=Object.prototype.hasOwnProperty,r={};((t,i)=>{for(var s in i)e(t,s,{get:i[s],enumerable:!0})})(r,{FluxStore:()=>c});var n,o=(n=r,((r,n,o,a)=>{if(n&&"object"==typeof n||"function"==typeof n)for(let h of i(n))s.call(r,h)||h===o||e(r,h,{get:()=>n[h],enumerable:!(a=t(n,h))||a.enumerable});return r})(e({},"__esModule",{value:!0}),n)),a=require("valyrian.js"),h=require("valyrian.js/utils"),c=class e{state;getters;init;rootStore;namespace;constructor({state:t={},mutations:i={},actions:s={},getters:r={},modules:n={},shouldFreeze:o=!0,namespace:a,rootStore:c}={}){const l="function"==typeof t?t():t;this.state=new Proxy(l||{},{get:(e,t)=>{if((this.rootStore||this).init.modules[t])return e[t];if(o){if(this.init.frozen)return(0,h.deepFreeze)(e[t]);const i=(0,h.deepCloneUnfreeze)(e);for(const e of Reflect.ownKeys(i))l[e]=i[e]}return e[t]},set:(e,t,i)=>{this.isUnfrozen();const s=e[t];return e[t]=i,this.namespace&&(t=`${this.namespace}.${t}`),(this.rootStore||this).trigger("set",t,i,s),!0},deleteProperty:(e,t)=>{this.isUnfrozen();const i=e[t];return Reflect.deleteProperty(e,t),this.namespace&&(t=`${this.namespace}.${t}`),(this.rootStore||this).trigger("delete",t,i),!0}}),this.rootStore=c||null,this.namespace=a||null,this.init={frozen:!0,plugins:[],modules:{},childModuleNamespaces:Object.keys(n||{}),listeners:{set:[],delete:[],beforecommit:[],commit:[],beforedispatch:[],dispatch:[],getter:[],addlistener:[],removelistener:[],plugin:[],registerModule:[],unregisterModule:[]},getters:r||{},mutations:i||{},actions:s||{}},this.getters=new Proxy(r||{},{get:(t,i)=>{try{const{store:t,key:s}=this.getStore(this,i);if(t instanceof e&&t.init.getters[s]){const e=t.init.getters[s](t.state,t.getters,this.state,this.getters);return this.namespace&&(i=`${this.namespace}.${i}`),(this.rootStore||this).trigger("getter",i,e),e}}catch(e){return}}}),n&&Object.keys(n).forEach(e=>{const t=this.namespace?`${this.namespace}.${e}`:e;(this.rootStore||this).registerModule(t,n[e])})}keyExists(e,t,i){if(!t[i])throw new Error(`The ${e} "${i}" does not exists.`)}isFunction(e,t){if("function"!=typeof t)throw new Error(`You need to provide a valid function as ${e}.`)}getStore(e,t){let i=t;if(i.indexOf(".")>-1){const t=i.split(".");i=t.pop();const s=t.join(".");this.keyExists("module",e.init.modules,s),e=e.init.modules[s]}return{store:e,key:i}}isUnfrozen(){if(this.init.frozen)throw new Error("You need to commit a mutation to change the state")}commit(e,...t){const{store:i,key:s}=this.getStore(this,e);this.keyExists("mutation",i.init.mutations,s),i.init.frozen=!1,this.trigger("beforecommit",e,...t),i.init.mutations[s](i.state,...t),this.trigger("commit",e,...t),i.init.frozen=!0,(0,a.debouncedUpdate)()}async dispatch(e,...t){const{store:i,key:s}=this.getStore(this,e);this.keyExists("action",i.init.actions,s),this.trigger("beforedispatch",e,...t);try{const r=await i.init.actions[s](i,...t);return this.trigger("dispatch",e,...t),r}finally{(0,a.debouncedUpdate)()}}trigger(e,...t){this.init.listeners[e].forEach(e=>e(this,...t))}on(e,t,i){if(this.isFunction("listener",t),i){const{store:s,key:r}=this.getStore(this,i);return this.keyExists("event",s.init.listeners,e),-1===s.init.listeners[e].indexOf(t)&&(s.init.listeners[e].push(t),this.trigger("addlistener",e,t)),()=>this.off(e,t)}return this.keyExists("event",this.init.listeners,e),-1===this.init.listeners[e].indexOf(t)&&(this.init.listeners[e].push(t),this.trigger("addlistener",e,t)),()=>this.off(e,t)}off(e,t){this.isFunction("listener",t),this.keyExists("event",this.init.listeners,e);const i=this.init.listeners[e].indexOf(t);i>-1&&(this.init.listeners[e].splice(i,1),this.trigger("removelistener",e,t))}use(e,...t){this.isFunction("plugin",e),-1===this.init.plugins.indexOf(e)&&(e(this,...t),this.init.plugins.push(e),this.trigger("plugin",e,...t))}registerModule(t,i){const s=this;if(s.init.modules[t])throw new Error(`A module with the namespace "${t}" is already registered.`);const r=new e({...i,rootStore:s,namespace:t});s.init.frozen=!1,s.init.modules[t]=r,s.state[t]=r.state,s.init.frozen=!0,s.trigger("registerModule",t,i,r),(0,a.debouncedUpdate)()}unregisterModule(e){const t=this,i=t.init.modules[e];i&&(i.init.childModuleNamespaces.forEach(i=>t.unregisterModule(`${e}.${i}`)),t.init.frozen=!1,Reflect.deleteProperty(t.init.modules,e),Reflect.deleteProperty(t.state,e),t.init.frozen=!0,t.trigger("unregisterModule",e,i),(0,a.debouncedUpdate)())}};"undefined"!=typeof module?module.exports=o:self.ValyrianFluxStore=o})();//# sourceMappingURL=index.min.js.map

package/dist/flux-store/index.min.js.map

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["flux_store_exports","__export","FluxStore","__EXPORTS__","import_valyrian","require","import_utils","_FluxStore","state","getters","init","rootStore","namespace","constructor","mutations","actions","modules","shouldFreeze","localState","this","Proxy","get","prop","frozen","deepFreeze","newState","deepCloneUnfreeze","key","Reflect","ownKeys","set","value","isUnfrozen","old","trigger","deleteProperty","plugins","childModuleNamespaces","Object","keys","listeners","delete","beforecommit","commit","beforedispatch","dispatch","getter","addlistener","removelistener","plugin","registerModule","unregisterModule","store","getStore","error","forEach","n","keyExists","objectname","object","Error","isFunction","type","callback","indexOf","parts","split","pop","moduleName","join","mutation","args","debouncedUpdate","action","result","event","on","listener","push","off","index","splice","use","options","module","newStore"],"sources":["../../lib/flux-store/index.ts"],"sourcesContent":["import { debouncedUpdate } from \"valyrian.js\";\nimport { deepCloneUnfreeze, deepFreeze } from \"valyrian.js/utils\";\n\ninterface StoreOptions {\n  state?: Record<string, any> | (() => Record<string, any>);\n  // eslint-disable-next-line no-unused-vars\n  mutations?: Record<string, (state: Record<string, any>, ...args: any[]) => void>;\n  // eslint-disable-next-line no-unused-vars, no-use-before-define\n  actions?: Record<string, (store: FluxStore, ...args: any[]) => any>;\n  getters?: Record<\n    string,\n    // eslint-disable-next-line no-unused-vars\n    (state: Record<string, any>, getters: Record<string, any>, globalState?: any, globalGetters?: any) => any\n  >;\n  modules?: Record<string, StoreOptions>;\n  shouldFreeze?: boolean;\n  namespace?: string;\n  // eslint-disable-next-line no-use-before-define\n  rootStore?: FluxStore;\n}\n\n// This is the store entity\nexport class FluxStore {\n  public state: Record<string, any>;\n  public getters: Record<string, any>;\n  private init: {\n    frozen: boolean;\n    plugins: Function[];\n    // eslint-disable-next-line no-use-before-define\n    modules: Record<string, FluxStore>;\n    childModuleNamespaces: string[];\n    listeners: Record<string, Function[]>;\n    getters: StoreOptions[\"getters\"];\n    mutations: StoreOptions[\"mutations\"];\n    actions: StoreOptions[\"actions\"];\n  };\n  // eslint-disable-next-line no-use-before-define\n  public rootStore: FluxStore | null;\n  public namespace: string | null;\n\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n  constructor({\n    state = {},\n    mutations = {},\n    actions = {},\n    getters = {},\n    modules = {},\n    shouldFreeze = true,\n    namespace,\n    rootStore\n  }: StoreOptions = {}) {\n    // Initialize the localState for this store\n    const localState = typeof state === \"function\" ? state() : state;\n\n    // We create a proxy for the state\n    this.state = new Proxy(localState || {}, {\n      // Every time we try to access a property from the state we try to deep freeze the property\n      // to prevent direct modifications to the state\n      get: (state, prop: string) => {\n        if ((this.rootStore || this).init.modules[prop]) {\n          return state[prop];\n        }\n        if (shouldFreeze) {\n          // We are accessing a property from outside the store\n          if (this.init.frozen) {\n            return deepFreeze(state[prop]);\n          }\n\n          // We are accessing a property from inside the store\n          // So we need to unfreeze the state\n          const newState = deepCloneUnfreeze(state);\n          for (const key of Reflect.ownKeys(newState)) {\n            localState[key] = newState[key];\n          }\n        }\n        return state[prop];\n      },\n      // If the user tries to set directly it will throw an error, only if we have unfrozen the state via commit\n      // this will proceed to set the value\n      set: (state, prop: string, value: any) => {\n        this.isUnfrozen();\n        const old = state[prop];\n        state[prop] = value;\n        if (this.namespace) {\n          prop = `${this.namespace}.${prop}`;\n        }\n        (this.rootStore || this).trigger(\"set\", prop, value, old);\n        return true;\n      },\n      // If the user tries to delete directly it will throw an error, only if we have unfrozen the state via commit\n      // this will proceed to delete the property\n      deleteProperty: (state, prop: string) => {\n        this.isUnfrozen();\n        const old = state[prop];\n        Reflect.deleteProperty(state, prop);\n        if (this.namespace) {\n          prop = `${this.namespace}.${prop}`;\n        }\n        (this.rootStore || this).trigger(\"delete\", prop, old);\n        return true;\n      }\n    });\n\n    // If this is a store been attached to another store\n    // this will have the rootStore for future reference\n    this.rootStore = rootStore || null;\n\n    // If this is a store been attached to another store\n    // this will have the namespace attached\n    this.namespace = namespace || null;\n\n    // We initialize the store with the initial values\n    this.init = {\n      frozen: true,\n      plugins: [],\n      modules: {},\n      childModuleNamespaces: Object.keys(modules || {}),\n      listeners: {\n        set: [],\n        delete: [],\n        beforecommit: [],\n        commit: [],\n        beforedispatch: [],\n        dispatch: [],\n        getter: [],\n        addlistener: [],\n        removelistener: [],\n        plugin: [],\n        registerModule: [],\n        unregisterModule: []\n      },\n      getters: getters || {},\n      mutations: mutations || {},\n      actions: actions || {}\n    };\n\n    // We create a proxy for the getters\n    this.getters = new Proxy(getters || {}, {\n      // When we try to get a property of the getter we will call the original\n      // getter method passing the state as first argument and the other getters as second\n      // if we try to get a non existent getter it will fail silently as if\n      // we were trying to get an undefined property\n      get: (getters, getter: string) => {\n        try {\n          const { store, key } = this.getStore(this, getter);\n          if (store instanceof FluxStore && store.init.getters![key]) {\n            const value = store.init.getters![key](store.state, store.getters, this.state, this.getters);\n            if (this.namespace) {\n              getter = `${this.namespace}.${getter}`;\n            }\n            (this.rootStore || this).trigger(\"getter\", getter, value);\n            return value;\n          }\n        } catch (error) {\n          return;\n        }\n      }\n    });\n\n    // Finally we attach the initial modules\n    if (modules) {\n      Object.keys(modules).forEach((namespace) => {\n        const n = this.namespace ? `${this.namespace}.${namespace}` : namespace;\n        (this.rootStore || this).registerModule(n, modules[namespace]);\n      });\n    }\n  }\n\n  private keyExists(objectname: string, object: Record<string, any>, key: string) {\n    if (!object[key]) {\n      throw new Error(`The ${objectname} \"${key}\" does not exists.`);\n    }\n  }\n\n  private isFunction(type: string, callback: Function) {\n    if (typeof callback !== \"function\") {\n      throw new Error(`You need to provide a valid function as ${type}.`);\n    }\n  }\n\n  // Giving a dot based namespace this method will be used to find the module to be called\n  private getStore(store: FluxStore, namespace: string) {\n    let key = namespace;\n    if (key.indexOf(\".\") > -1) {\n      const parts = key.split(\".\");\n      key = parts.pop()!;\n      const moduleName = parts.join(\".\");\n      this.keyExists(\"module\", store.init.modules, moduleName);\n      store = store.init.modules[moduleName];\n    }\n    return {\n      store,\n      key\n    };\n  }\n\n  private isUnfrozen() {\n    if (this.init.frozen) {\n      throw new Error(\"You need to commit a mutation to change the state\");\n    }\n  }\n\n  // This method unfroze the state and process a mutation\n  public commit(mutation: string, ...args: any[]) {\n    const { store, key } = this.getStore(this, mutation);\n    this.keyExists(\"mutation\", store.init.mutations!, key);\n    store.init.frozen = false;\n    this.trigger(\"beforecommit\", mutation, ...args);\n    store.init.mutations![key](store.state, ...args);\n    this.trigger(\"commit\", mutation, ...args);\n    store.init.frozen = true;\n\n    // We call the debounced update to notify the changes\n    debouncedUpdate();\n  }\n\n  // This method will dispatch an action\n  public async dispatch(action: string, ...args: any[]): Promise<any> {\n    const { store, key } = this.getStore(this, action);\n    this.keyExists(\"action\", store.init.actions!, key);\n    this.trigger(\"beforedispatch\", action, ...args);\n    try {\n      const result = await store.init.actions![key](store, ...args);\n      this.trigger(\"dispatch\", action, ...args);\n      return result;\n    } finally {\n      debouncedUpdate();\n    }\n  }\n\n  // This method will trigger an event\n  public trigger(event: string, ...args: any[]) {\n    this.init.listeners[event].forEach((callback) => callback(this, ...args));\n  }\n\n  // This method will add a listener to the store\n  public on(event: string, listener: Function, namespace?: string) {\n    this.isFunction(\"listener\", listener);\n\n    if (namespace) {\n      const { store, key } = this.getStore(this, namespace);\n      this.keyExists(\"event\", store.init.listeners, event);\n      if (store.init.listeners[event].indexOf(listener) === -1) {\n        store.init.listeners[event].push(listener);\n        this.trigger(\"addlistener\", event, listener);\n      }\n      return () => this.off(event, listener);\n    }\n\n    this.keyExists(\"event\", this.init.listeners, event);\n    if (this.init.listeners[event].indexOf(listener) === -1) {\n      this.init.listeners[event].push(listener);\n      this.trigger(\"addlistener\", event, listener);\n    }\n    return () => this.off(event, listener);\n  }\n\n  // Remove a listener from the store\n  public off(event: string, listener: Function) {\n    this.isFunction(\"listener\", listener);\n    this.keyExists(\"event\", this.init.listeners, event);\n    const index = this.init.listeners[event].indexOf(listener);\n    if (index > -1) {\n      this.init.listeners[event].splice(index, 1);\n      this.trigger(\"removelistener\", event, listener);\n    }\n  }\n\n  // This method will add a plugin to the store\n  public use(plugin: Function, ...options: any[]) {\n    this.isFunction(\"plugin\", plugin);\n    if (this.init.plugins.indexOf(plugin) === -1) {\n      plugin(this, ...options);\n      this.init.plugins.push(plugin);\n      this.trigger(\"plugin\", plugin, ...options);\n    }\n  }\n\n  // This method will register a module to the store\n  public registerModule(namespace: string, module: StoreOptions) {\n    const rootStore = this;\n    if (rootStore.init.modules[namespace]) {\n      throw new Error(`A module with the namespace \"${namespace}\" is already registered.`);\n    }\n    const newStore = new FluxStore({ ...module, rootStore, namespace });\n    rootStore.init.frozen = false;\n    rootStore.init.modules[namespace] = newStore;\n    rootStore.state[namespace] = newStore.state;\n    rootStore.init.frozen = true;\n    rootStore.trigger(\"registerModule\", namespace, module, newStore);\n\n    // We call the debounced update to notify the changes\n    debouncedUpdate();\n  }\n\n  // This method will unregister a module from the store\n  public unregisterModule(namespace: string) {\n    const rootStore = this;\n    const store = rootStore.init.modules[namespace];\n    if (store) {\n      store.init.childModuleNamespaces.forEach((n) => rootStore.unregisterModule(`${namespace}.${n}`));\n      rootStore.init.frozen = false;\n      Reflect.deleteProperty(rootStore.init.modules, namespace);\n      Reflect.deleteProperty(rootStore.state, namespace);\n      rootStore.init.frozen = true;\n      rootStore.trigger(\"unregisterModule\", namespace, store);\n\n      // We call the debounced update to notify the changes\n      debouncedUpdate();\n    }\n  }\n}\n"],"mappings":"gJAAAA,EAAA,G,yDAAAC,CAAAD,EAAA,CAAAE,UAAA,IAAAA,IAAA,I,EAAAC,G,EAAAH,E,0MAAAI,EAAgCC,QAAA,eAChCC,EAA8CD,QAAA,qBAqBjCH,EAAN,MAAMK,EACJC,MACAC,QACCC,KAYDC,UACAC,UAGP,WAAAC,EAAYL,MACVA,EAAQ,CAAC,EAAAM,UACTA,EAAY,CAAC,EAAAC,QACbA,EAAU,CAAC,EAAAN,QACXA,EAAU,CAAC,EAAAO,QACXA,EAAU,CAAC,EAAAC,aACXA,GAAe,EAAAL,UACfA,EAAAD,UACAA,GACgB,CAAC,GAEjB,MAAMO,EAA8B,mBAAVV,EAAuBA,IAAUA,EAG3DW,KAAKX,MAAQ,IAAIY,MAAMF,GAAc,CAAC,EAAG,CAGvCG,IAAK,CAACb,EAAOc,KACX,IAAKH,KAAKR,WAAaQ,MAAMT,KAAKM,QAAQM,GACxC,OAAOd,EAAMc,GAEf,GAAIL,EAAc,CAEhB,GAAIE,KAAKT,KAAKa,OACZ,SAAOjB,EAAAkB,YAAWhB,EAAMc,IAK1B,MAAMG,GAAA,EAAWnB,EAAAoB,mBAAkBlB,GACnC,UAAWmB,KAAOC,QAAQC,QAAQJ,GAChCP,EAAWS,GAAOF,EAASE,EAE/B,CACA,OAAOnB,EAAMc,EAAI,EAInBQ,IAAK,CAACtB,EAAOc,EAAcS,KACzBZ,KAAKa,aACL,MAAMC,EAAMzB,EAAMc,GAMlB,OALAd,EAAMc,GAAQS,EACVZ,KAAKP,YACPU,EAAO,GAAGH,KAAKP,aAAaU,MAE7BH,KAAKR,WAAaQ,MAAMe,QAAQ,MAAOZ,EAAMS,EAAOE,IAC9C,GAITE,eAAgB,CAAC3B,EAAOc,KACtBH,KAAKa,aACL,MAAMC,EAAMzB,EAAMc,GAMlB,OALAM,QAAQO,eAAe3B,EAAOc,GAC1BH,KAAKP,YACPU,EAAO,GAAGH,KAAKP,aAAaU,MAE7BH,KAAKR,WAAaQ,MAAMe,QAAQ,SAAUZ,EAAMW,IAC1C,KAMXd,KAAKR,UAAYA,GAAa,KAI9BQ,KAAKP,UAAYA,GAAa,KAG9BO,KAAKT,KAAO,CACVa,QAAQ,EACRa,QAAS,GACTpB,QAAS,CAAC,EACVqB,sBAAuBC,OAAOC,KAAKvB,GAAW,CAAC,GAC/CwB,UAAW,CACTV,IAAK,GACLW,OAAQ,GACRC,aAAc,GACdC,OAAQ,GACRC,eAAgB,GAChBC,SAAU,GACVC,OAAQ,GACRC,YAAa,GACbC,eAAgB,GAChBC,OAAQ,GACRC,eAAgB,GAChBC,iBAAkB,IAEpB1C,QAASA,GAAW,CAAC,EACrBK,UAAWA,GAAa,CAAC,EACzBC,QAASA,GAAW,CAAC,GAIvBI,KAAKV,QAAU,IAAIW,MAAMX,GAAW,CAAC,EAAG,CAKtCY,IAAK,CAACZ,EAASqC,KACb,IACE,MAAMM,MAAEA,EAAAzB,IAAOA,GAAQR,KAAKkC,SAASlC,KAAM2B,GAC3C,GAAIM,aAAiB7C,GAAa6C,EAAM1C,KAAKD,QAASkB,GAAM,CAC1D,MAAMI,EAAQqB,EAAM1C,KAAKD,QAASkB,GAAKyB,EAAM5C,MAAO4C,EAAM3C,QAASU,KAAKX,MAAOW,KAAKV,SAKpF,OAJIU,KAAKP,YACPkC,EAAS,GAAG3B,KAAKP,aAAakC,MAE/B3B,KAAKR,WAAaQ,MAAMe,QAAQ,SAAUY,EAAQf,GAC5CA,CACT,CACF,OAASuB,GACP,MACF,KAKAtC,GACFsB,OAAOC,KAAKvB,GAASuC,QAAS3C,IAC5B,MAAM4C,EAAIrC,KAAKP,UAAY,GAAGO,KAAKP,aAAaA,IAAcA,GAC7DO,KAAKR,WAAaQ,MAAM+B,eAAeM,EAAGxC,EAAQJ,GAAU,EAGnE,CAEQ,SAAA6C,CAAUC,EAAoBC,EAA6BhC,GACjE,IAAKgC,EAAOhC,GACV,MAAM,IAAIiC,MAAM,OAAOF,MAAe/B,sBAE1C,CAEQ,UAAAkC,CAAWC,EAAcC,GAC/B,GAAwB,mBAAbA,EACT,MAAM,IAAIH,MAAM,2CAA2CE,KAE/D,CAGQ,QAAAT,CAASD,EAAkBxC,GACjC,IAAIe,EAAMf,EACV,GAAIe,EAAIqC,QAAQ,MAAO,EAAI,CACzB,MAAMC,EAAQtC,EAAIuC,MAAM,KACxBvC,EAAMsC,EAAME,MACZ,MAAMC,EAAaH,EAAMI,KAAK,KAC9BlD,KAAKsC,UAAU,SAAUL,EAAM1C,KAAKM,QAASoD,GAC7ChB,EAAQA,EAAM1C,KAAKM,QAAQoD,EAC7B,CACA,MAAO,CACLhB,QACAzB,MAEJ,CAEQ,UAAAK,GACN,GAAIb,KAAKT,KAAKa,OACZ,MAAM,IAAIqC,MAAM,oDAEpB,CAGO,MAAAjB,CAAO2B,KAAqBC,GACjC,MAAMnB,MAAEA,EAAAzB,IAAOA,GAAQR,KAAKkC,SAASlC,KAAMmD,GAC3CnD,KAAKsC,UAAU,WAAYL,EAAM1C,KAAKI,UAAYa,GAClDyB,EAAM1C,KAAKa,QAAS,EACpBJ,KAAKe,QAAQ,eAAgBoC,KAAaC,GAC1CnB,EAAM1C,KAAKI,UAAWa,GAAKyB,EAAM5C,SAAU+D,GAC3CpD,KAAKe,QAAQ,SAAUoC,KAAaC,GACpCnB,EAAM1C,KAAKa,QAAS,GAGpB,EAAAnB,EAAAoE,kBACF,CAGA,cAAa3B,CAAS4B,KAAmBF,GACvC,MAAMnB,MAAEA,EAAAzB,IAAOA,GAAQR,KAAKkC,SAASlC,KAAMsD,GAC3CtD,KAAKsC,UAAU,SAAUL,EAAM1C,KAAKK,QAAUY,GAC9CR,KAAKe,QAAQ,iBAAkBuC,KAAWF,GAC1C,IACE,MAAMG,QAAetB,EAAM1C,KAAKK,QAASY,GAAKyB,KAAUmB,GAExD,OADApD,KAAKe,QAAQ,WAAYuC,KAAWF,GAC7BG,CACT,UACE,EAAAtE,EAAAoE,kBACF,CACF,CAGO,OAAAtC,CAAQyC,KAAkBJ,GAC/BpD,KAAKT,KAAK8B,UAAUmC,GAAOpB,QAASQ,GAAaA,EAAS5C,QAASoD,GACrE,CAGO,EAAAK,CAAGD,EAAeE,EAAoBjE,GAG3C,GAFAO,KAAK0C,WAAW,WAAYgB,GAExBjE,EAAW,CACb,MAAMwC,MAAEA,EAAAzB,IAAOA,GAAQR,KAAKkC,SAASlC,KAAMP,GAM3C,OALAO,KAAKsC,UAAU,QAASL,EAAM1C,KAAK8B,UAAWmC,IACQ,IAAlDvB,EAAM1C,KAAK8B,UAAUmC,GAAOX,QAAQa,KACtCzB,EAAM1C,KAAK8B,UAAUmC,GAAOG,KAAKD,GACjC1D,KAAKe,QAAQ,cAAeyC,EAAOE,IAE9B,IAAM1D,KAAK4D,IAAIJ,EAAOE,EAC/B,CAOA,OALA1D,KAAKsC,UAAU,QAAStC,KAAKT,KAAK8B,UAAWmC,IACQ,IAAjDxD,KAAKT,KAAK8B,UAAUmC,GAAOX,QAAQa,KACrC1D,KAAKT,KAAK8B,UAAUmC,GAAOG,KAAKD,GAChC1D,KAAKe,QAAQ,cAAeyC,EAAOE,IAE9B,IAAM1D,KAAK4D,IAAIJ,EAAOE,EAC/B,CAGO,GAAAE,CAAIJ,EAAeE,GACxB1D,KAAK0C,WAAW,WAAYgB,GAC5B1D,KAAKsC,UAAU,QAAStC,KAAKT,KAAK8B,UAAWmC,GAC7C,MAAMK,EAAQ7D,KAAKT,KAAK8B,UAAUmC,GAAOX,QAAQa,GAC7CG,GAAQ,IACV7D,KAAKT,KAAK8B,UAAUmC,GAAOM,OAAOD,EAAO,GACzC7D,KAAKe,QAAQ,iBAAkByC,EAAOE,GAE1C,CAGO,GAAAK,CAAIjC,KAAqBkC,GAC9BhE,KAAK0C,WAAW,SAAUZ,IACgB,IAAtC9B,KAAKT,KAAK0B,QAAQ4B,QAAQf,KAC5BA,EAAO9B,QAASgE,GAChBhE,KAAKT,KAAK0B,QAAQ0C,KAAK7B,GACvB9B,KAAKe,QAAQ,SAAUe,KAAWkC,GAEtC,CAGO,cAAAjC,CAAetC,EAAmBwE,GACvC,MAAMzE,EAAYQ,KAClB,GAAIR,EAAUD,KAAKM,QAAQJ,GACzB,MAAM,IAAIgD,MAAM,gCAAgChD,6BAElD,MAAMyE,EAAW,IAAI9E,EAAU,IAAK6E,EAAQzE,YAAWC,cACvDD,EAAUD,KAAKa,QAAS,EACxBZ,EAAUD,KAAKM,QAAQJ,GAAayE,EACpC1E,EAAUH,MAAMI,GAAayE,EAAS7E,MACtCG,EAAUD,KAAKa,QAAS,EACxBZ,EAAUuB,QAAQ,iBAAkBtB,EAAWwE,EAAQC,IAGvD,EAAAjF,EAAAoE,kBACF,CAGO,gBAAArB,CAAiBvC,GACtB,MAAMD,EAAYQ,KACZiC,EAAQzC,EAAUD,KAAKM,QAAQJ,GACjCwC,IACFA,EAAM1C,KAAK2B,sBAAsBkB,QAASC,GAAM7C,EAAUwC,iBAAiB,GAAGvC,KAAa4C,MAC3F7C,EAAUD,KAAKa,QAAS,EACxBK,QAAQO,eAAexB,EAAUD,KAAKM,QAASJ,GAC/CgB,QAAQO,eAAexB,EAAUH,MAAOI,GACxCD,EAAUD,KAAKa,QAAS,EACxBZ,EAAUuB,QAAQ,mBAAoBtB,EAAWwC,IAGjD,EAAAhD,EAAAoE,mBAEJ,G"}