@nlabs/arkhamjs 3.20.4 → 3.22.1

package/lib/Flux/Flux.test.js

@@ -0,0 +1,717 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var import_debounce = __toESM(require("lodash/debounce"));
+var import_cloneDeep = __toESM(require("lodash/fp/cloneDeep"));
+var import_set = __toESM(require("lodash/fp/set"));
+var import_ArkhamConstants = require("../constants/ArkhamConstants");
+var import_Flux = require("./Flux");
+jest.mock("lodash/debounce");
+const initialState = {
+  falsy: false,
+  item: "default",
+  testAction: "default",
+  testUpdate: "default",
+  zeroValue: 0
+};
+const helloStore = (type, data, state = initialState) => {
+  switch (type) {
+    case "TEST_EVENT":
+      return (0, import_set.default)("testAction", data.testVar, state);
+    default:
+      return state;
+  }
+};
+describe("Flux", () => {
+  const consoleError = console.error;
+  const consoleWarn = console.warn;
+  const cfg = {
+    name: "arkhamjsTest",
+    stores: [helloStore]
+  };
+  let Flux;
+  beforeAll(() => {
+    console.error = jest.fn();
+    console.warn = jest.fn();
+  });
+  beforeEach(async () => {
+    Flux = new import_Flux.FluxFramework();
+    await Flux.init(cfg, true);
+  });
+  afterAll(() => {
+    console.error = consoleError;
+    console.warn = consoleWarn;
+  });
+  describe("#addMiddleware", () => {
+    describe("should apply pre-dispatch middleware", () => {
+      const middleTest = "intercept object";
+      const objMiddleware = {
+        name: "objectMiddleware",
+        preDispatch: (action) => __spreadProps(__spreadValues({}, action), { testVar: middleTest })
+      };
+      afterEach(() => {
+        Flux.clearMiddleware();
+      });
+      it("should alter data before sending to stores", async () => {
+        Flux.addMiddleware([objMiddleware]);
+        Flux.setState("helloStore.testAction", "default");
+        const preAction = await Flux.dispatch({ testVar: "hello world", type: "TEST_EVENT" });
+        expect(Flux.getState("helloStore.testAction")).toEqual(middleTest);
+        expect(preAction.testVar).toEqual(middleTest);
+      });
+      it("should handle error for middleware without a name", () => {
+        const fn = () => Flux.addMiddleware([{ preDispatch: objMiddleware.preDispatch }]);
+        expect(fn).toThrowError();
+      });
+      it("should handle error for incompatible middleware", () => {
+        const fn = () => Flux.addMiddleware(["incorrect"]);
+        expect(fn).toThrowError();
+      });
+    });
+    describe("should apply pre-dispatch middleware as promise", () => {
+      const middleTest = "intercept promise";
+      beforeEach(() => {
+        const promiseMiddleware = {
+          name: "promiseMiddleware",
+          preDispatch: (action) => Promise.resolve(__spreadProps(__spreadValues({}, action), { testVar: middleTest }))
+        };
+        Flux.addMiddleware([promiseMiddleware]);
+      });
+      afterEach(() => {
+        Flux.clearMiddleware();
+      });
+      it("should alter data before sending to stores", async () => {
+        Flux.setState("helloStore.testAction", "default");
+        const preAction = await Flux.dispatch({ testVar: "hello world", type: "TEST_EVENT" });
+        expect(Flux.getState("helloStore.testAction")).toEqual(middleTest);
+        expect(preAction.testVar).toEqual(middleTest);
+      });
+    });
+    describe("should apply post dispatch middleware", () => {
+      const middleTest = "intercept post";
+      beforeEach(() => {
+        const postMiddleware = {
+          name: "postMiddleware",
+          postDispatch: (action) => Promise.resolve(__spreadProps(__spreadValues({}, action), { testVar: middleTest }))
+        };
+        Flux.addMiddleware([postMiddleware]);
+      });
+      afterEach(() => {
+        Flux.clearMiddleware();
+      });
+      it("should alter store data", async () => {
+        Flux.setState("helloStore.testAction", "default");
+        const postAction = await Flux.dispatch({ testVar: "hello world", type: "TEST_EVENT" });
+        expect(Flux.getState("helloStore.testAction")).toEqual("hello world");
+        expect(postAction.testVar).toEqual(middleTest);
+      });
+      it("should handle no action error", async () => {
+        await expect(Flux.dispatch(null)).rejects.toThrowError();
+      });
+      it("should handle pre dispatch error", async () => {
+        const preMiddleware = {
+          name: "errorMiddleware",
+          preDispatch: () => Promise.reject(new Error("test"))
+        };
+        Flux.addMiddleware([preMiddleware]);
+        await expect(Flux.dispatch({ type: "test" })).rejects.toThrowError();
+      });
+      it("should handle post dispatch error", async () => {
+        const postMiddleware = {
+          name: "errorMiddleware",
+          postDispatch: () => Promise.reject(new Error("test"))
+        };
+        Flux.addMiddleware([postMiddleware]);
+        await expect(Flux.dispatch({ type: "test" })).rejects.toThrowError();
+      });
+    });
+  });
+  describe("#addPlugin", () => {
+    it("should add a plugin", () => {
+      const addPluginKey = "addPlugin";
+      const plugin = { method: () => {
+      }, name: "demoPlugin" };
+      const results = Flux[addPluginKey]("preDispatch", plugin);
+      expect(results).toEqual([plugin]);
+    });
+    it("should skip plugin if already exists", () => {
+      const addPluginKey = "addPlugin";
+      const plugin = { method: () => {
+      }, name: "demoPlugin" };
+      Flux.middleware.preDispatchList = [plugin];
+      const results = Flux[addPluginKey]("preDispatch", plugin);
+      expect(results).toEqual([plugin]);
+    });
+    it("should handle undefined function", () => {
+      const addPluginKey = "addPlugin";
+      const fn = () => Flux[addPluginKey]("preDispatch", { method: "object" });
+      expect(fn).toThrowError();
+    });
+  });
+  describe("#clearAppData", () => {
+    beforeEach(() => {
+      Flux.setState("helloStore.item", "clear");
+    });
+    it("should reset the store data", async () => {
+      await Flux.clearAppData();
+      expect(Flux.getState(["helloStore", "item"])).toEqual("default");
+    });
+    it("should set data in storage", async () => {
+      const retrnedValue = { hello: "world" };
+      const setStorageData = jest.fn().mockResolvedValue(retrnedValue);
+      Flux.options.storage = { setStorageData };
+      const results = await Flux.clearAppData();
+      expect(setStorageData.mock.calls.length).toEqual(1);
+      expect(results).toEqual(retrnedValue);
+    });
+  });
+  describe("#deregister", () => {
+    it("should remove a state and store", () => {
+      Flux.state = { hello: "world" };
+      Flux.storeActions = { hello: "world" };
+      Flux.deregister("hello");
+      expect(Flux.state).toEqual({});
+      expect(Flux.storeActions).toEqual({});
+    });
+    it("should use empty string as default", () => {
+      const originalState = (0, import_cloneDeep.default)(Flux.state);
+      Flux.deregister();
+      expect(originalState).toEqual(Flux.state);
+    });
+  });
+  describe("#dispatch", () => {
+    let eventSpy;
+    beforeEach(() => {
+      eventSpy = jest.fn();
+      Flux.on("TEST_EVENT", eventSpy);
+    });
+    afterEach(() => {
+      Flux.off("TEST_EVENT", eventSpy);
+    });
+    it("should return an action", async () => {
+      Flux.dispatch({ testVar: "test", type: "TEST_EVENT" });
+      const action = await Flux.dispatch({ testVar: "test", type: "TEST_EVENT" });
+      expect(action).toEqual({ testVar: "test", type: "TEST_EVENT" });
+    });
+    it("should alter the store data", () => {
+      Flux.dispatch({ testVar: "test", type: "TEST_EVENT" });
+      const item = Flux.getState("helloStore.testAction");
+      expect(item).toEqual("test");
+    });
+    it("should dispatch an event", () => {
+      Flux.dispatch({ testVar: "test", type: "TEST_EVENT" });
+      expect(eventSpy.mock.calls.length).toEqual(1);
+    });
+    it("should not dispatch if no type", () => {
+      Flux.dispatch({ testVar: "test" });
+      expect(eventSpy.mock.calls.length).toEqual(0);
+    });
+    it("should not dispatch if silent", () => {
+      Flux.dispatch({ testVar: "test", type: "TEST_EVENT" }, true);
+      expect(eventSpy.mock.calls.length).toEqual(0);
+    });
+    it("should update storage", () => {
+      Flux.updateStorage = jest.fn().mockResolvedValue({});
+      Flux.options.storage = {};
+      Flux.dispatch({ testVar: "test", type: "TEST_EVENT" });
+      expect(Flux.updateStorage.mock.calls.length).toEqual(1);
+    });
+    it("should return updated state if action returns null", async () => {
+      const nullStore = (type, data, state = initialState) => {
+        switch (type) {
+          case "TEST_NULL":
+            return null;
+          default:
+            return state;
+        }
+      };
+      await Flux.addStores([nullStore]);
+      await Flux.dispatch({ testVar: "test", type: "TEST_NULL" });
+      expect(Flux.state.nullStore).toEqual(initialState);
+    });
+    it("should return empty object if store returns null by default", async () => {
+      const nullStore = (type, data, state) => {
+        switch (type) {
+          case "TEST_NULL":
+            return null;
+          default:
+            return state;
+        }
+      };
+      await Flux.addStores([nullStore]);
+      Flux.state.nullStore = null;
+      await Flux.dispatch({ testVar: "test", type: "TEST_NULL" });
+      expect(Flux.state.nullStore).toEqual({});
+    });
+  });
+  describe("#getOptions", () => {
+    it("should get a options object", () => {
+      const options = Flux.getOptions();
+      const optionsKey = "options";
+      expect(options).toEqual(Flux[optionsKey]);
+    });
+  });
+  describe("#getState", () => {
+    beforeEach(() => {
+      const storeAction = Flux.getStore("helloStore");
+      Flux.setState("helloStore", storeAction.initialState);
+    });
+    it("should get a global store", () => {
+      const value = Flux.getState();
+      expect(value.helloStore.item).toEqual("default");
+    });
+    it("should get a specific store returning an object", () => {
+      const value = Flux.getState("helloStore");
+      expect(value.item).toEqual("default");
+    });
+    it("should get a specific item within a store using array", () => {
+      const value = Flux.getState(["helloStore", "item"]);
+      expect(value).toEqual("default");
+    });
+    it("should get a specific item within a store using dot notation", () => {
+      const value = Flux.getState("helloStore.item");
+      expect(value).toEqual("default");
+    });
+    it("should return default value from a null item", () => {
+      const value = Flux.getState("helloStore.notDefault", "");
+      expect(value).toEqual("");
+    });
+    it("should return entire store object with empty key", () => {
+      const value = Flux.getState("");
+      expect(value).toEqual({ helloStore: initialState });
+    });
+    it("should return entire store object with null key", () => {
+      const value = Flux.getState(null);
+      expect(value).toEqual({ helloStore: initialState });
+    });
+    it("should return entire store object with undefined key", () => {
+      const value = Flux.getState();
+      expect(value).toEqual({ helloStore: initialState });
+    });
+    it("should return empty object if state is null", () => {
+      Flux.state = null;
+      const value = Flux.getState();
+      expect(value).toEqual({});
+    });
+    it("should return a false value", () => {
+      const value = Flux.getState("helloStore.falsy");
+      expect(value).toEqual(false);
+    });
+    it("should return a zero value", () => {
+      const value = Flux.getState("helloStore.zeroValue");
+      expect(value).toEqual(0);
+    });
+  });
+  describe("#getStore", () => {
+    it("should get a store function", () => {
+      const storeAction = Flux.getStore("helloStore");
+      expect(storeAction.name).toEqual("helloStore");
+    });
+    it("should use empty string as default value", () => {
+      const storeAction = Flux.getStore();
+      expect(storeAction).toBeUndefined();
+    });
+  });
+  describe("#init", () => {
+    describe("set app name", () => {
+      const opts = {
+        name: "demo"
+      };
+      it("should update app name if initializing for the first time", async () => {
+        const privateInit = "isInit";
+        Flux[privateInit] = false;
+        await Flux.init(opts);
+        const optionsKey = "options";
+        expect(Flux[optionsKey].name).toEqual("demo");
+      });
+      it("should not update app name if initializing again", async () => {
+        const privateInit = "isInit";
+        Flux[privateInit] = true;
+        await Flux.init(opts);
+        const optionsKey = "options";
+        expect(Flux[optionsKey].name).toEqual("arkhamjsTest");
+      });
+      it("should add windows object for debugging", async () => {
+        await Flux.init(__spreadProps(__spreadValues({}, opts), { debug: true }));
+        const debugKey = "arkhamjs";
+        expect(window[debugKey]).toEqual(Flux);
+      });
+      it("should use default object if undefined", async () => {
+        await Flux.reset();
+        await Flux.init();
+        const optionsKey = "options";
+        const expectedOptions = {
+          name: "arkhamjs",
+          routerType: "browser",
+          scrollToTop: true,
+          state: null,
+          storage: null,
+          storageWait: 300,
+          stores: [],
+          title: "ArkhamJS"
+        };
+        expect(Flux[optionsKey]).toEqual(expectedOptions);
+      });
+    });
+    describe("set app name for initialized app", () => {
+      const opts = {
+        name: "demo"
+      };
+      it("should set app name", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "options";
+        expect(Flux[privateProperty].name).toEqual("demo");
+      });
+    });
+    describe("set initial empty state", () => {
+      const opts = {
+        state: {},
+        stores: [helloStore]
+      };
+      it("should set state", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Object.keys(Flux[privateProperty]).length).toEqual(1);
+      });
+      it("should set state branch for store", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Flux[privateProperty].helloStore.item).toEqual("default");
+      });
+    });
+    describe("set null state", () => {
+      const opts = {
+        state: null,
+        stores: [helloStore]
+      };
+      it("should set state", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Object.keys(Flux[privateProperty]).length).toEqual(1);
+      });
+      it("should set state branch for store", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Flux[privateProperty].helloStore.item).toEqual("default");
+      });
+    });
+    describe("set defined state", () => {
+      const opts = {
+        state: { second: "value", test: { hello: "world" } },
+        stores: [helloStore]
+      };
+      it("should set state", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Object.keys(Flux[privateProperty]).length).toEqual(3);
+      });
+      it("should set state branch for store", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "state";
+        expect(Flux[privateProperty].test.hello).toEqual("world");
+      });
+    });
+    describe("middleware", () => {
+      const objMiddleware = {
+        name: "objectMiddleware",
+        preDispatch: (action) => __spreadValues({}, action)
+      };
+      const opts = {
+        middleware: [objMiddleware],
+        name: "demo",
+        stores: [helloStore]
+      };
+      it("should add middleware", async () => {
+        await Flux.init(opts, true);
+        const privateProperty = "middleware";
+        expect(Flux[privateProperty].preDispatchList[0].name).toEqual("objectMiddleware");
+      });
+    });
+    describe("error handling", () => {
+      it("should handle useStorage error", async () => {
+        Flux.useStorage = Promise.reject(new Error("test"));
+        await expect(Flux.init(cfg, true)).rejects.toThrowError();
+      });
+      it("should handle addStores error", async () => {
+        Flux.addStores = Promise.reject(new Error("test"));
+        await expect(Flux.init(cfg, true)).rejects.toThrowError();
+      });
+    });
+  });
+  describe("event listeners", () => {
+    let eventSpy;
+    beforeEach(() => {
+      eventSpy = jest.fn();
+      Flux.on("test", eventSpy);
+    });
+    describe("#on", () => {
+      it("should add a listener", async () => {
+        await Flux.dispatch({ type: "test" });
+        expect(eventSpy.mock.calls.length).toEqual(1);
+      });
+    });
+    describe("#off", () => {
+      it("should remove a listener", async () => {
+        Flux.off("test", eventSpy);
+        await Flux.dispatch({ type: "test" });
+        expect(eventSpy.mock.calls.length).toEqual(0);
+      });
+    });
+  });
+  describe("#addStores", () => {
+    const demo = (type, data, state = { helloStore: "joker" }) => {
+      if (type === "DEMO_TEST") {
+        state.helloStore = data.helloStore;
+      }
+      return state;
+    };
+    it("should create and save a Store class", () => {
+      Flux.addStores([demo]);
+      const privateProperty = "storeActions";
+      const storeAction = Flux[privateProperty].demo;
+      expect(storeAction.name).toEqual("demo");
+    });
+    it("should set initial state", () => {
+      Flux.addStores([demo]);
+      const privateProperty = "storeActions";
+      const storeAction = Flux[privateProperty].demo;
+      expect(storeAction.initialState).toEqual({ helloStore: "joker" });
+    });
+    it("should handle unsupported stores", () => {
+      const optionsKey = "options";
+      const setStorageData = new Error("test");
+      Flux[optionsKey].storage = { setStorageData };
+      Flux.addStores([demo]);
+      const privateProperty = "storeActions";
+      const storeAction = Flux[privateProperty].demo;
+      expect(storeAction.initialState).toEqual({ helloStore: "joker" });
+    });
+  });
+  describe("#offInit", () => {
+    it("should remove listener after initialization", () => {
+      const listener = jest.fn();
+      Flux.off = jest.fn();
+      Flux.offInit(listener);
+      expect(Flux.off.mock.calls.length).toEqual(1);
+      expect(Flux.off.mock.calls[0][0]).toEqual(import_ArkhamConstants.ArkhamConstants.INIT);
+    });
+  });
+  describe("#onInit", () => {
+    it("should add listener after initialization", () => {
+      const listener = jest.fn();
+      Flux.isInit = false;
+      Flux.on = jest.fn();
+      Flux.onInit(listener);
+      expect(Flux.on.mock.calls.length).toEqual(1);
+      expect(Flux.on.mock.calls[0][0]).toEqual(import_ArkhamConstants.ArkhamConstants.INIT);
+    });
+    it("should dispatch instantly if already initialized", () => {
+      const listener = jest.fn();
+      Flux.isInit = true;
+      Flux.onInit(listener);
+      expect(listener.mock.calls.length).toEqual(1);
+    });
+  });
+  describe("#register", () => {
+    it("should register a store function", () => {
+      const demoStore = (type, data, state = initialState) => {
+        switch (type) {
+          case "TEST_EVENT":
+            return (0, import_set.default)("testAction", data.testVar, state);
+          default:
+            return state;
+        }
+      };
+      const registerKey = "register";
+      const storeAction = Flux[registerKey](demoStore);
+      const expectedAction = {
+        action: demoStore,
+        initialState,
+        name: "demoStore"
+      };
+      expect(storeAction).toEqual(expectedAction);
+    });
+    it("should register a store function without an initial value", () => {
+      const demoStore = (type, data, state) => {
+        switch (type) {
+          case "TEST_EVENT":
+            return (0, import_set.default)("testAction", data.testVar, state);
+          default:
+            return state;
+        }
+      };
+      const registerKey = "register";
+      const storeAction = Flux[registerKey](demoStore);
+      const expectedAction = {
+        action: demoStore,
+        initialState: void 0,
+        name: "demoStore"
+      };
+      expect(storeAction).toEqual(expectedAction);
+    });
+    it("should not save a store function without a name", () => {
+      const registerKey = "register";
+      const storeAction = Flux[registerKey]((type, data, state = initialState) => {
+        switch (type) {
+          case "TEST_EVENT":
+            return (0, import_set.default)("testAction", data.testVar, state);
+          default:
+            return state;
+        }
+      });
+      expect(storeAction).toBeUndefined();
+    });
+    it("should handle undefined function", () => {
+      const registerKey = "register";
+      const fn = () => Flux[registerKey]();
+      expect(fn).toThrowError();
+    });
+    it("should handle argument that is not a function", () => {
+      const registerKey = "register";
+      const fn = () => Flux[registerKey]({});
+      expect(fn).toThrowError();
+    });
+  });
+  describe("#removeMiddleware", () => {
+    beforeEach(() => {
+      Flux.clearMiddleware();
+      const objMiddleware = {
+        name: "objectMiddleware",
+        preDispatch: (action) => __spreadValues({}, action)
+      };
+      Flux.addMiddleware([objMiddleware]);
+    });
+    it("should alter data before sending to stores", () => {
+      Flux.removeMiddleware(["objectMiddleware"]);
+      const privateProperty = "middleware";
+      expect(Flux[privateProperty].preDispatchList.length).toEqual(0);
+    });
+  });
+  describe("#removePlugin", () => {
+    it("should remove an existing plugin", () => {
+      Flux.middleware.preDispatchList = [{ name: "demoPlugin" }, { name: "noNotRemovePlugin" }];
+      expect(Flux.removePlugin("preDispatch", "demoPlugin")).toEqual([{ name: "noNotRemovePlugin" }]);
+    });
+    it("should get an undefined list", () => {
+      Flux.middleware.preDispatchList = null;
+      expect(Flux.removePlugin("preDispatch", "demoPlugin")).toEqual([]);
+    });
+  });
+  describe("#removeStores", () => {
+    beforeEach(() => {
+      Flux.removeStores(["helloStore"]);
+    });
+    afterEach(() => {
+      Flux.addStores([helloStore]);
+    });
+    it("should remove class", () => {
+      const privateProperty = "storeActions";
+      expect(!!Flux[privateProperty].helloStore).toEqual(false);
+    });
+    it("should remove store data", () => {
+      const privateProperty = "state";
+      expect(!!Flux[privateProperty].helloStore).toEqual(false);
+    });
+  });
+  describe("#reset", () => {
+    it("should handle argument that is not a function", async () => {
+      const optionsKey = "options";
+      const setStorageData = new Error("test");
+      Flux[optionsKey].storage = { setStorageData };
+      await expect(Flux.reset()).rejects.toThrowError();
+    });
+  });
+  describe("#setState", () => {
+    it("should update the property within the store", async () => {
+      await Flux.setState("helloStore.testUpdate", "test");
+      const newItem = await Flux.getState("helloStore.testUpdate");
+      expect(newItem).toEqual("test");
+    });
+    it("should empty string as default path", async () => {
+      await Flux.setState(void 0, "test");
+      const newItem = await Flux.getState("helloStore");
+      expect(newItem).toEqual(initialState);
+    });
+    it("should update storage", async () => {
+      const optionsKey = "options";
+      const updateStorageKey = "updateStorage";
+      const updateStorage = jest.fn();
+      Flux[optionsKey] = { storage: {} };
+      Flux[updateStorageKey] = updateStorage;
+      await Flux.setState("helloStore.testUpdate", "test");
+      expect(updateStorage.mock.calls.length).toEqual(1);
+    });
+  });
+  describe("#useStorage", () => {
+    it("should update storage", async () => {
+      const getStorageData = jest.fn();
+      const optionsKey = "options";
+      Flux[optionsKey].state = null;
+      Flux[optionsKey].storage = { getStorageData };
+      const useStorageKey = "useStorage";
+      await Flux[useStorageKey]("helloStore");
+      expect(getStorageData.mock.calls.length).toEqual(1);
+    });
+    it("without storage", async () => {
+      const optionsKey = "options";
+      Flux[optionsKey].state = { hello: "world" };
+      Flux[optionsKey].storage = null;
+      const useStorageKey = "useStorage";
+      await Flux[useStorageKey]("helloStore");
+      const stateKey = "state";
+      expect(Flux[stateKey].hello).toEqual("world");
+    });
+    it("should handle storage errors", async () => {
+      const optionsKey = "options";
+      Flux[optionsKey].state = null;
+      Flux[optionsKey].storage = new Error("test");
+      const useStorageKey = "useStorage";
+      await expect(Flux[useStorageKey]("helloStore")).rejects.toThrowError();
+    });
+    it("should debounce storage", async () => {
+      const value = "test";
+      const optionsKey = "options";
+      Flux[optionsKey].state = { hello: "world" };
+      const setStorageData = jest.fn().mockReturnValue(value);
+      Flux[optionsKey].storage = { setStorageData };
+      const debounceMock = import_debounce.default;
+      debounceMock.mockImplementation((fn) => fn());
+      const useStorageKey = "useStorage";
+      await Flux[useStorageKey]("helloStore");
+      expect(setStorageData.mock.calls.length).toEqual(1);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Flux/Flux.test.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 debounce from 'lodash/debounce';\nimport cloneDeep from 'lodash/fp/cloneDeep';\nimport set from 'lodash/fp/set';\n\nimport {ArkhamConstants} from '../constants/ArkhamConstants';\nimport {FluxFramework} from './Flux';\nimport {FluxAction, FluxOptions, FluxStore} from './Flux.types';\n\njest.mock('lodash/debounce');\n\nconst initialState = {\n  falsy: false,\n  item: 'default',\n  testAction: 'default',\n  testUpdate: 'default',\n  zeroValue: 0\n};\n\nconst helloStore = (type: string, data, state = initialState): any => {\n  switch(type) {\n    case 'TEST_EVENT':\n      return set('testAction', data.testVar, state);\n    default:\n      return state;\n  }\n};\n\ndescribe('Flux', () => {\n  const consoleError = console.error;\n  const consoleWarn = console.warn;\n  const cfg: FluxOptions = {\n    name: 'arkhamjsTest',\n    stores: [helloStore]\n  };\n  let Flux;\n\n  beforeAll(() => {\n    console.error = jest.fn();\n    console.warn = jest.fn();\n  });\n\n  beforeEach(async () => {\n    Flux = new FluxFramework();\n\n    // Configure\n    await Flux.init(cfg, true);\n  });\n\n  afterAll(() => {\n    console.error = consoleError;\n    console.warn = consoleWarn;\n  });\n\n  describe('#addMiddleware', () => {\n    describe('should apply pre-dispatch middleware', () => {\n      const middleTest: string = 'intercept object';\n\n      // Add object middleware\n      const objMiddleware = {\n        name: 'objectMiddleware',\n        preDispatch: (action) => ({...action, testVar: middleTest})\n      };\n\n      afterEach(() => {\n        Flux.clearMiddleware();\n      });\n\n      it('should alter data before sending to stores', async () => {\n        // Method\n        Flux.addMiddleware([objMiddleware]);\n\n        // Set test data\n        Flux.setState('helloStore.testAction', 'default');\n\n        // Dispatch an action\n        const preAction: FluxAction = await Flux.dispatch({testVar: 'hello world', type: 'TEST_EVENT'});\n\n        expect(Flux.getState('helloStore.testAction')).toEqual(middleTest);\n        expect(preAction.testVar).toEqual(middleTest);\n      });\n\n      it('should handle error for middleware without a name', () => {\n        const fn = () => Flux.addMiddleware([{preDispatch: objMiddleware.preDispatch}]);\n        expect(fn).toThrowError();\n      });\n\n      it('should handle error for incompatible middleware', () => {\n        const fn = () => Flux.addMiddleware(['incorrect']);\n        expect(fn).toThrowError();\n      });\n    });\n\n    describe('should apply pre-dispatch middleware as promise', () => {\n      const middleTest: string = 'intercept promise';\n\n      beforeEach(() => {\n        // Add object middleware\n        const promiseMiddleware = {\n          name: 'promiseMiddleware',\n          preDispatch: (action) => Promise.resolve({...action, testVar: middleTest})\n        };\n\n        Flux.addMiddleware([promiseMiddleware]);\n      });\n\n      afterEach(() => {\n        Flux.clearMiddleware();\n      });\n\n      it('should alter data before sending to stores', async () => {\n        // Set test data\n        Flux.setState('helloStore.testAction', 'default');\n\n        // Dispatch an action\n        const preAction: FluxAction = await Flux.dispatch({testVar: 'hello world', type: 'TEST_EVENT'});\n        expect(Flux.getState('helloStore.testAction')).toEqual(middleTest);\n        expect(preAction.testVar).toEqual(middleTest);\n      });\n    });\n\n    describe('should apply post dispatch middleware', () => {\n      const middleTest: string = 'intercept post';\n\n      beforeEach(() => {\n        // Add object middleware\n        const postMiddleware = {\n          name: 'postMiddleware',\n          postDispatch: (action) => Promise.resolve({...action, testVar: middleTest})\n        };\n\n        Flux.addMiddleware([postMiddleware]);\n      });\n\n      afterEach(() => {\n        Flux.clearMiddleware();\n      });\n\n      it('should alter store data', async () => {\n        // Set test data\n        Flux.setState('helloStore.testAction', 'default');\n\n        // Dispatch an action\n        const postAction: FluxAction = await Flux.dispatch({testVar: 'hello world', type: 'TEST_EVENT'});\n\n        expect(Flux.getState('helloStore.testAction')).toEqual('hello world');\n        expect(postAction.testVar).toEqual(middleTest);\n      });\n\n      it('should handle no action error', async () => {\n        await expect(Flux.dispatch(null)).rejects.toThrowError();\n      });\n\n      it('should handle pre dispatch error', async () => {\n        const preMiddleware = {\n          name: 'errorMiddleware',\n          preDispatch: () => Promise.reject(new Error('test'))\n        };\n        Flux.addMiddleware([preMiddleware]);\n        await expect(Flux.dispatch({type: 'test'})).rejects.toThrowError();\n      });\n\n      it('should handle post dispatch error', async () => {\n        const postMiddleware = {\n          name: 'errorMiddleware',\n          postDispatch: () => Promise.reject(new Error('test'))\n        };\n        Flux.addMiddleware([postMiddleware]);\n        await expect(Flux.dispatch({type: 'test'})).rejects.toThrowError();\n      });\n    });\n  });\n\n  describe('#addPlugin', () => {\n    it('should add a plugin', () => {\n      const addPluginKey: string = 'addPlugin';\n      const plugin = {method: () => {}, name: 'demoPlugin'};\n      const results = Flux[addPluginKey]('preDispatch', plugin);\n      expect(results).toEqual([plugin]);\n    });\n\n    it('should skip plugin if already exists', () => {\n      const addPluginKey: string = 'addPlugin';\n      const plugin = {method: () => {}, name: 'demoPlugin'};\n      Flux.middleware.preDispatchList = [plugin];\n      const results = Flux[addPluginKey]('preDispatch', plugin);\n      expect(results).toEqual([plugin]);\n    });\n\n    it('should handle undefined function', () => {\n      const addPluginKey: string = 'addPlugin';\n      const fn = () => Flux[addPluginKey]('preDispatch', {method: 'object'});\n      expect(fn).toThrowError();\n    });\n  });\n\n  describe('#clearAppData', () => {\n    beforeEach(() => {\n      // Set test data\n      Flux.setState('helloStore.item', 'clear');\n    });\n\n    it('should reset the store data', async () => {\n      // Method\n      await Flux.clearAppData();\n\n      expect(Flux.getState(['helloStore', 'item'])).toEqual('default');\n    });\n\n    it('should set data in storage', async () => {\n      const retrnedValue = {hello: 'world'};\n      const setStorageData = jest.fn().mockResolvedValue(retrnedValue);\n      Flux.options.storage = {setStorageData};\n\n      // Method\n      const results = await Flux.clearAppData();\n\n      expect(setStorageData.mock.calls.length).toEqual(1);\n      expect(results).toEqual(retrnedValue);\n    });\n  });\n\n  describe('#deregister', () => {\n    it('should remove a state and store', () => {\n      Flux.state = {hello: 'world'};\n      Flux.storeActions = {hello: 'world'};\n      Flux.deregister('hello');\n      expect(Flux.state).toEqual({});\n      expect(Flux.storeActions).toEqual({});\n    });\n\n    it('should use empty string as default', () => {\n      const originalState = cloneDeep(Flux.state);\n      Flux.deregister();\n      expect(originalState).toEqual(Flux.state);\n    });\n  });\n\n  describe('#dispatch', () => {\n    let eventSpy;\n\n    beforeEach(() => {\n      // Spy\n      eventSpy = jest.fn();\n      Flux.on('TEST_EVENT', eventSpy);\n    });\n\n    afterEach(() => {\n      Flux.off('TEST_EVENT', eventSpy);\n    });\n\n    it('should return an action', async () => {\n      // Method\n      Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'});\n\n      const action: any = await Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'});\n      expect(action).toEqual({testVar: 'test', type: 'TEST_EVENT'});\n    });\n\n    it('should alter the store data', () => {\n      // Method\n      Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'});\n\n      const item: string = Flux.getState('helloStore.testAction');\n      expect(item).toEqual('test');\n    });\n\n    it('should dispatch an event', () => {\n      // Method\n      Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'});\n\n      expect(eventSpy.mock.calls.length).toEqual(1);\n    });\n\n    it('should not dispatch if no type', () => {\n      // Method\n      Flux.dispatch({testVar: 'test'});\n\n      expect(eventSpy.mock.calls.length).toEqual(0);\n    });\n\n    it('should not dispatch if silent', () => {\n      // Method\n      Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'}, true);\n\n      expect(eventSpy.mock.calls.length).toEqual(0);\n    });\n\n    it('should update storage', () => {\n      Flux.updateStorage = jest.fn().mockResolvedValue({});\n      Flux.options.storage = {};\n\n      // Method\n      Flux.dispatch({testVar: 'test', type: 'TEST_EVENT'});\n\n      expect(Flux.updateStorage.mock.calls.length).toEqual(1);\n    });\n\n    it('should return updated state if action returns null', async () => {\n      // Add null store\n      const nullStore = (type: string, data, state = initialState): any => {\n        switch(type) {\n          case 'TEST_NULL':\n            return null;\n          default:\n            return state;\n        }\n      };\n      await Flux.addStores([nullStore]);\n\n      // Method\n      await Flux.dispatch({testVar: 'test', type: 'TEST_NULL'});\n\n      expect(Flux.state.nullStore).toEqual(initialState);\n    });\n\n    it('should return empty object if store returns null by default', async () => {\n      // Add null store\n      const nullStore = (type: string, data, state): any => {\n        switch(type) {\n          case 'TEST_NULL':\n            return null;\n          default:\n            return state;\n        }\n      };\n      await Flux.addStores([nullStore]);\n      Flux.state.nullStore = null;\n\n      // Method\n      await Flux.dispatch({testVar: 'test', type: 'TEST_NULL'});\n\n      expect(Flux.state.nullStore).toEqual({});\n    });\n  });\n\n  describe('#getOptions', () => {\n    it('should get a options object', () => {\n      const options = Flux.getOptions();\n      const optionsKey: string = 'options';\n      expect(options).toEqual(Flux[optionsKey]);\n    });\n  });\n\n  describe('#getState', () => {\n    beforeEach(() => {\n      const storeAction = Flux.getStore('helloStore');\n      Flux.setState('helloStore', storeAction.initialState);\n    });\n\n    it('should get a global store', () => {\n      const value = Flux.getState();\n      expect(value.helloStore.item).toEqual('default');\n    });\n\n    it('should get a specific store returning an object', () => {\n      const value = Flux.getState('helloStore');\n      expect(value.item).toEqual('default');\n    });\n\n    it('should get a specific item within a store using array', () => {\n      const value: string = Flux.getState(['helloStore', 'item']);\n      expect(value).toEqual('default');\n    });\n\n    it('should get a specific item within a store using dot notation', () => {\n      const value: string = Flux.getState('helloStore.item');\n      expect(value).toEqual('default');\n    });\n\n    it('should return default value from a null item', () => {\n      const value: string = Flux.getState('helloStore.notDefault', '');\n      expect(value).toEqual('');\n    });\n\n    it('should return entire store object with empty key', () => {\n      const value: string = Flux.getState('');\n      expect(value).toEqual({helloStore: initialState});\n    });\n\n    it('should return entire store object with null key', () => {\n      const value: string = Flux.getState(null);\n      expect(value).toEqual({helloStore: initialState});\n    });\n\n    it('should return entire store object with undefined key', () => {\n      const value: string = Flux.getState();\n      expect(value).toEqual({helloStore: initialState});\n    });\n\n    it('should return empty object if state is null', () => {\n      Flux.state = null;\n      const value: string = Flux.getState();\n      expect(value).toEqual({});\n    });\n\n    it('should return a false value', () => {\n      const value = Flux.getState('helloStore.falsy');\n      expect(value).toEqual(false);\n    });\n\n    it('should return a zero value', () => {\n      const value = Flux.getState('helloStore.zeroValue');\n      expect(value).toEqual(0);\n    });\n  });\n\n  describe('#getStore', () => {\n    it('should get a store function', () => {\n      const storeAction = Flux.getStore('helloStore');\n      expect(storeAction.name).toEqual('helloStore');\n    });\n\n    it('should use empty string as default value', () => {\n      const storeAction = Flux.getStore();\n      expect(storeAction).toBeUndefined();\n    });\n  });\n\n  describe('#init', () => {\n    describe('set app name', () => {\n      // Vars\n      const opts: FluxOptions = {\n        name: 'demo'\n      };\n\n      it('should update app name if initializing for the first time', async () => {\n        const privateInit: string = 'isInit';\n        Flux[privateInit] = false;\n\n        // Method\n        await Flux.init(opts);\n\n        const optionsKey: string = 'options';\n        expect(Flux[optionsKey].name).toEqual('demo');\n      });\n\n      it('should not update app name if initializing again', async () => {\n        const privateInit: string = 'isInit';\n        Flux[privateInit] = true;\n\n        // Method\n        await Flux.init(opts);\n\n        const optionsKey: string = 'options';\n        expect(Flux[optionsKey].name).toEqual('arkhamjsTest');\n      });\n\n      it('should add windows object for debugging', async () => {\n        // Method\n        await Flux.init({...opts, debug: true});\n\n        const debugKey: string = 'arkhamjs';\n        expect(window[debugKey]).toEqual(Flux);\n      });\n\n      it('should use default object if undefined', async () => {\n        // Method\n        await Flux.reset();\n        await Flux.init();\n\n        const optionsKey: string = 'options';\n        const expectedOptions = {\n          name: 'arkhamjs',\n          routerType: 'browser',\n          scrollToTop: true,\n          state: null,\n          storage: null,\n          storageWait: 300,\n          stores: [],\n          title: 'ArkhamJS'\n        };\n        expect(Flux[optionsKey]).toEqual(expectedOptions);\n      });\n    });\n\n    describe('set app name for initialized app', () => {\n      // Vars\n      const opts: FluxOptions = {\n        name: 'demo'\n      };\n\n      it('should set app name', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'options';\n        expect(Flux[privateProperty].name).toEqual('demo');\n      });\n    });\n\n    describe('set initial empty state', () => {\n      // Vars\n      const opts: FluxOptions = {\n        state: {},\n        stores: [helloStore]\n      };\n\n      it('should set state', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Object.keys(Flux[privateProperty]).length).toEqual(1);\n      });\n\n      it('should set state branch for store', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Flux[privateProperty].helloStore.item).toEqual('default');\n      });\n    });\n\n    describe('set null state', () => {\n      // Vars\n      const opts: FluxOptions = {\n        state: null,\n        stores: [helloStore]\n      };\n\n      it('should set state', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Object.keys(Flux[privateProperty]).length).toEqual(1);\n      });\n\n      it('should set state branch for store', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Flux[privateProperty].helloStore.item).toEqual('default');\n      });\n    });\n\n    describe('set defined state', () => {\n      // Vars\n      const opts: FluxOptions = {\n        state: {second: 'value', test: {hello: 'world'}},\n        stores: [helloStore]\n      };\n\n      it('should set state', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Object.keys(Flux[privateProperty]).length).toEqual(3);\n      });\n\n      it('should set state branch for store', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'state';\n        expect(Flux[privateProperty].test.hello).toEqual('world');\n      });\n    });\n\n    describe('middleware', () => {\n      // Middleware object\n      const objMiddleware = {\n        name: 'objectMiddleware',\n        preDispatch: (action) => ({...action})\n      };\n\n      // Vars\n      const opts: FluxOptions = {\n        middleware: [objMiddleware],\n        name: 'demo',\n        stores: [helloStore]\n      };\n\n      it('should add middleware', async () => {\n        await Flux.init(opts, true);\n        const privateProperty: string = 'middleware';\n        expect(Flux[privateProperty].preDispatchList[0].name).toEqual('objectMiddleware');\n      });\n    });\n\n    describe('error handling', () => {\n      it('should handle useStorage error', async () => {\n        Flux.useStorage = Promise.reject(new Error('test'));\n        await expect(Flux.init(cfg, true)).rejects.toThrowError();\n      });\n\n      it('should handle addStores error', async () => {\n        Flux.addStores = Promise.reject(new Error('test'));\n        await expect(Flux.init(cfg, true)).rejects.toThrowError();\n      });\n    });\n  });\n\n  describe('event listeners', () => {\n    let eventSpy;\n\n    beforeEach(() => {\n      eventSpy = jest.fn();\n      Flux.on('test', eventSpy);\n    });\n\n    describe('#on', () => {\n      it('should add a listener', async () => {\n        await Flux.dispatch({type: 'test'});\n        expect(eventSpy.mock.calls.length).toEqual(1);\n      });\n    });\n\n    describe('#off', () => {\n      it('should remove a listener', async () => {\n        Flux.off('test', eventSpy);\n        await Flux.dispatch({type: 'test'});\n\n        expect(eventSpy.mock.calls.length).toEqual(0);\n      });\n    });\n  });\n\n  describe('#addStores', () => {\n    const demo = (type, data, state = {helloStore: 'joker'}) => {\n      if(type === 'DEMO_TEST') {\n        state.helloStore = data.helloStore;\n      }\n\n      return state;\n    };\n\n    it('should create and save a Store class', () => {\n      Flux.addStores([demo]);\n      const privateProperty: string = 'storeActions';\n      const storeAction: FluxStore = Flux[privateProperty].demo;\n      expect(storeAction.name).toEqual('demo');\n    });\n\n    it('should set initial state', () => {\n      Flux.addStores([demo]);\n      const privateProperty: string = 'storeActions';\n      const storeAction: FluxStore = Flux[privateProperty].demo;\n      expect(storeAction.initialState).toEqual({helloStore: 'joker'});\n    });\n\n    it('should handle unsupported stores', () => {\n      const optionsKey: string = 'options';\n      const setStorageData = new Error('test');\n      Flux[optionsKey].storage = {setStorageData};\n\n      Flux.addStores([demo]);\n      const privateProperty: string = 'storeActions';\n      const storeAction: FluxStore = Flux[privateProperty].demo;\n      expect(storeAction.initialState).toEqual({helloStore: 'joker'});\n    });\n  });\n\n  describe('#offInit', () => {\n    it('should remove listener after initialization', () => {\n      const listener = jest.fn();\n      Flux.off = jest.fn();\n      Flux.offInit(listener);\n      expect(Flux.off.mock.calls.length).toEqual(1);\n      expect(Flux.off.mock.calls[0][0]).toEqual(ArkhamConstants.INIT);\n    });\n  });\n\n  describe('#onInit', () => {\n    it('should add listener after initialization', () => {\n      const listener = jest.fn();\n      Flux.isInit = false;\n      Flux.on = jest.fn();\n      Flux.onInit(listener);\n      expect(Flux.on.mock.calls.length).toEqual(1);\n      expect(Flux.on.mock.calls[0][0]).toEqual(ArkhamConstants.INIT);\n    });\n\n    it('should dispatch instantly if already initialized', () => {\n      const listener = jest.fn();\n      Flux.isInit = true;\n      Flux.onInit(listener);\n      expect(listener.mock.calls.length).toEqual(1);\n    });\n  });\n\n  describe('#register', () => {\n    it('should register a store function', () => {\n      const demoStore = (type: string, data, state = initialState): any => {\n        switch(type) {\n          case 'TEST_EVENT':\n            return set('testAction', data.testVar, state);\n          default:\n            return state;\n        }\n      };\n\n      const registerKey: string = 'register';\n      const storeAction = Flux[registerKey](demoStore);\n      const expectedAction = {\n        action: demoStore,\n        initialState,\n        name: 'demoStore'\n      };\n      expect(storeAction).toEqual(expectedAction);\n    });\n\n    it('should register a store function without an initial value', () => {\n      const demoStore = (type: string, data, state): any => {\n        switch(type) {\n          case 'TEST_EVENT':\n            return set('testAction', data.testVar, state);\n          default:\n            return state;\n        }\n      };\n\n      const registerKey: string = 'register';\n      const storeAction = Flux[registerKey](demoStore);\n      const expectedAction = {\n        action: demoStore,\n        initialState: undefined,\n        name: 'demoStore'\n      };\n      expect(storeAction).toEqual(expectedAction);\n    });\n\n    it('should not save a store function without a name', () => {\n      const registerKey: string = 'register';\n      const storeAction = Flux[registerKey]((type: string, data, state = initialState): any => {\n        switch(type) {\n          case 'TEST_EVENT':\n            return set('testAction', data.testVar, state);\n          default:\n            return state;\n        }\n      });\n      expect(storeAction).toBeUndefined();\n    });\n\n    it('should handle undefined function', () => {\n      const registerKey: string = 'register';\n\n      const fn = () => Flux[registerKey]();\n      expect(fn).toThrowError();\n    });\n\n    it('should handle argument that is not a function', () => {\n      const registerKey: string = 'register';\n\n      const fn = () => Flux[registerKey]({});\n      expect(fn).toThrowError();\n    });\n  });\n\n  describe('#removeMiddleware', () => {\n    beforeEach(() => {\n      Flux.clearMiddleware();\n\n      // Add object middleware\n      const objMiddleware = {\n        name: 'objectMiddleware',\n        preDispatch: (action) => ({...action})\n      };\n\n      Flux.addMiddleware([objMiddleware]);\n    });\n\n    it('should alter data before sending to stores', () => {\n      Flux.removeMiddleware(['objectMiddleware']);\n      const privateProperty: string = 'middleware';\n      expect(Flux[privateProperty].preDispatchList.length).toEqual(0);\n    });\n  });\n\n  describe('#removePlugin', () => {\n    it('should remove an existing plugin', () => {\n      Flux.middleware.preDispatchList = [{name: 'demoPlugin'}, {name: 'noNotRemovePlugin'}];\n      expect(Flux.removePlugin('preDispatch', 'demoPlugin')).toEqual([{name: 'noNotRemovePlugin'}]);\n    });\n\n    it('should get an undefined list', () => {\n      Flux.middleware.preDispatchList = null;\n      expect(Flux.removePlugin('preDispatch', 'demoPlugin')).toEqual([]);\n    });\n  });\n\n  describe('#removeStores', () => {\n    beforeEach(() => {\n      // Method\n      Flux.removeStores(['helloStore']);\n    });\n\n    afterEach(() => {\n      Flux.addStores([helloStore]);\n    });\n\n    it('should remove class', () => {\n      const privateProperty: string = 'storeActions';\n      expect(!!Flux[privateProperty].helloStore).toEqual(false);\n    });\n\n    it('should remove store data', () => {\n      const privateProperty: string = 'state';\n      expect(!!Flux[privateProperty].helloStore).toEqual(false);\n    });\n  });\n\n  describe('#reset', () => {\n    it('should handle argument that is not a function', async () => {\n      const optionsKey: string = 'options';\n      const setStorageData = new Error('test');\n      Flux[optionsKey].storage = {setStorageData};\n      await expect(Flux.reset()).rejects.toThrowError();\n    });\n  });\n\n  describe('#setState', () => {\n    it('should update the property within the store', async () => {\n      await Flux.setState('helloStore.testUpdate', 'test');\n      const newItem = await Flux.getState('helloStore.testUpdate');\n      expect(newItem).toEqual('test');\n    });\n\n    it('should empty string as default path', async () => {\n      await Flux.setState(undefined, 'test');\n      const newItem = await Flux.getState('helloStore');\n      expect(newItem).toEqual(initialState);\n    });\n\n    it('should update storage', async () => {\n      const optionsKey: string = 'options';\n      const updateStorageKey: string = 'updateStorage';\n      const updateStorage = jest.fn();\n      Flux[optionsKey] = {storage: {}};\n      Flux[updateStorageKey] = updateStorage;\n      await Flux.setState('helloStore.testUpdate', 'test');\n      expect(updateStorage.mock.calls.length).toEqual(1);\n    });\n  });\n\n  describe('#useStorage', () => {\n    it('should update storage', async () => {\n      const getStorageData = jest.fn();\n      const optionsKey: string = 'options';\n      Flux[optionsKey].state = null;\n      Flux[optionsKey].storage = {getStorageData};\n\n      const useStorageKey: string = 'useStorage';\n      await Flux[useStorageKey]('helloStore');\n\n      expect(getStorageData.mock.calls.length).toEqual(1);\n    });\n\n    it('without storage', async () => {\n      const optionsKey: string = 'options';\n      Flux[optionsKey].state = {hello: 'world'};\n      Flux[optionsKey].storage = null;\n\n      const useStorageKey: string = 'useStorage';\n      await Flux[useStorageKey]('helloStore');\n\n      const stateKey: string = 'state';\n      expect(Flux[stateKey].hello).toEqual('world');\n    });\n\n    it('should handle storage errors', async () => {\n      const optionsKey: string = 'options';\n      Flux[optionsKey].state = null;\n      Flux[optionsKey].storage = new Error('test');\n\n      const useStorageKey: string = 'useStorage';\n      await expect(Flux[useStorageKey]('helloStore')).rejects.toThrowError();\n    });\n\n    it('should debounce storage', async () => {\n      const value: string = 'test';\n      const optionsKey: string = 'options';\n      Flux[optionsKey].state = {hello: 'world'};\n\n      const setStorageData = jest.fn().mockReturnValue(value);\n      Flux[optionsKey].storage = {setStorageData};\n\n      const debounceMock: any = debounce;\n      debounceMock.mockImplementation((fn) => fn());\n\n      const useStorageKey: string = 'useStorage';\n      await Flux[useStorageKey]('helloStore');\n\n      expect(setStorageData.mock.calls.length).toEqual(1);\n    });\n  });\n});\n"],
  "mappings": "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",
  "names": []
}
