polystore 0.11.1 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "A small compatibility layer for many popular KV stores like localStorage, Redis, FileSystem, etc.",
   "homepage": "https://polystore.dev/",
   "repository": "https://github.com/franciscop/polystore.git",
@@ -16,7 +16,7 @@
   "scripts": {
     "size": "echo $(gzip -c src/index.js | wc -c) bytes",
     "start": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch --coverage --detectOpenHandles",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --ci --watchAll=false --detectOpenHandles && check-dts src/index.types.ts"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --ci --watchAll=false --detectOpenHandles && check-dts test/index.types.ts"
   },
   "keywords": [
     "kv",
@@ -54,11 +54,8 @@
   "jest": {
     "testEnvironment": "jsdom",
     "setupFiles": [
-      "./src/test/setup.js"
+      "./test/setup.js"
     ],
-    "transform": {},
-    "modulePathIgnorePatterns": [
-      "src/test/"
-    ]
+    "transform": {}
   }
 }

package/src/index.test.js

@@ -1,631 +0,0 @@
-import "dotenv/config";
-
-import { jest } from "@jest/globals";
-import { EdgeKVNamespace as KVNamespace } from "edge-mock";
-import { Etcd3 } from "etcd3";
-import { Level } from "level";
-import localForage from "localforage";
-import { createClient } from "redis";
-
-import kv from "./index.js";
-import customFull from "./test/customFull.js";
-import customSimple from "./test/customSimple.js";
-
-const stores = [];
-stores.push(["kv()", kv()]);
-stores.push(["kv(new Map())", kv(new Map())]);
-stores.push(["kv(localStorage)", kv(localStorage)]);
-stores.push(["kv(sessionStorage)", kv(sessionStorage)]);
-stores.push(["kv(localForage)", kv(localForage)]);
-const path = `file://${process.cwd()}/src/test/data.json`;
-stores.push([`kv(new URL("${path}"))`, kv(new URL(path))]);
-const path2 = `file://${process.cwd()}/src/test/data.json`;
-stores.push([`kv("${path2}")`, kv(path2)]);
-stores.push([`kv("cookie")`, kv("cookie")]);
-stores.push(["kv(new KVNamespace())", kv(new KVNamespace())]);
-stores.push([`kv(new Level("data"))`, kv(new Level("data"))]);
-if (process.env.REDIS) {
-  stores.push(["kv(redis)", kv(createClient())]);
-}
-if (process.env.ETCD) {
-  // Note: need to add to .env "ETCD=true" and run `etcd` in the terminal
-  stores.push(["kv(new Etcd3())", kv(new Etcd3())]);
-}
-
-stores.push(["kv(customSimple)", kv(customSimple)]);
-stores.push(["kv(customFull)", kv(customFull)]);
-
-const delay = (t) => new Promise((done) => setTimeout(done, t));
-
-class Base {
-  get() {}
-  set() {}
-  *iterate() {}
-}
-
-global.console = {
-  ...console,
-  warn: jest.fn(),
-};
-
-describe("potato", () => {
-  it("a potato is not a valid store", async () => {
-    await expect(() => kv("potato").get("any")).rejects.toThrow();
-  });
-
-  it("an empty object is not a valid store", async () => {
-    await expect(() => kv({}).get("any")).rejects.toThrow({
-      message: "A client should have at least a .get(), .set() and .iterate()",
-    });
-  });
-
-  it("cannot handle no EXPIRES + keys", async () => {
-    await expect(() =>
-      kv(
-        class extends Base {
-          has() {}
-        }
-      ).get("any")
-    ).rejects.toThrow({
-      message:
-        "You can only define client.has() when the client manages the expiration; otherwise please do NOT define .has() and let us manage it",
-    });
-  });
-
-  it("cannot handle no EXPIRES + keys", async () => {
-    await expect(() =>
-      kv(
-        class extends Base {
-          keys() {}
-        }
-      ).get("any")
-    ).rejects.toThrow({
-      message:
-        "You can only define client.keys() when the client manages the expiration; otherwise please do NOT define .keys() and let us manage them",
-    });
-  });
-
-  it("warns the user with no EXPIRES + .values()", async () => {
-    const warn = jest
-      .spyOn(console, "warn")
-      .mockImplementationOnce(() => "Hello");
-    await kv(
-      class extends Base {
-        values() {}
-      }
-    ).get("any");
-    expect(warn).toHaveBeenCalled(); // But at least we warn them
-    warn.mockClear();
-  });
-});
-
-for (let [name, store] of stores) {
-  describe(name, () => {
-    beforeEach(async () => {
-      await store.clear();
-    });
-
-    afterAll(async () => {
-      await store.clear();
-      await store.close();
-    });
-
-    it("can perform a CRUD", async () => {
-      expect(await store.get("a")).toBe(null);
-      expect(await store.has("a")).toBe(false);
-      expect(await store.set("a", "b")).toBe("a");
-      expect(await store.has("a")).toBe(true);
-      expect(await store.get("a")).toBe("b");
-      expect(await store.del("a")).toBe("a");
-      expect(await store.get("a")).toBe(null);
-    });
-
-    it("is empty on the start", async () => {
-      expect(await store.get("a")).toBe(null);
-      expect(await store.has("a")).toBe(false);
-    });
-
-    it("can add() arbitrary values", async () => {
-      const key = await store.add("b");
-      expect(typeof key).toBe("string");
-      expect(await store.get(key)).toBe("b");
-      expect(await store.has(key)).toBe(true);
-      expect(key.length).toBe(24);
-      expect(key).toMatch(/^[a-zA-Z0-9]{24}$/);
-    });
-
-    it("can store values", async () => {
-      const key = await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-      expect(await store.has("a")).toBe(true);
-      expect(key).toBe("a");
-    });
-
-    it("can store values with a semicolon", async () => {
-      const key = await store.set("a", "b;c");
-      expect(await store.get("a")).toBe("b;c");
-      expect(await store.has("a")).toBe(true);
-      expect(key).toBe("a");
-    });
-
-    it("can store values with an equal", async () => {
-      const key = await store.set("a", "b=c");
-      expect(await store.get("a")).toBe("b=c");
-      expect(await store.has("a")).toBe(true);
-      expect(key).toBe("a");
-    });
-
-    it("can store values with a semicolon in the key", async () => {
-      const key = await store.set("a;b", "c");
-      expect(await store.get("a;b")).toBe("c");
-      expect(await store.has("a;b")).toBe(true);
-      expect(key).toBe("a;b");
-    });
-
-    it("can store values with an equal in the key", async () => {
-      const key = await store.set("a=b", "c");
-      expect(await store.get("a=b")).toBe("c");
-      expect(await store.has("a=b")).toBe(true);
-      expect(key).toBe("a=b");
-    });
-
-    it("can store basic types", async () => {
-      await store.set("a", 10);
-      expect(await store.get("a")).toEqual(10);
-      await store.set("a", "b");
-      expect(await store.get("a")).toEqual("b");
-      await store.set("a", true);
-      expect(await store.get("a")).toEqual(true);
-    });
-
-    it("can store arrays of JSON values", async () => {
-      await store.set("a", ["b", "c"]);
-      expect(await store.get("a")).toEqual(["b", "c"]);
-      expect(await store.has("a")).toBe(true);
-    });
-
-    it("can store objects", async () => {
-      await store.set("a", { b: "c" });
-      expect(await store.get("a")).toEqual({ b: "c" });
-      expect(await store.has("a")).toBe(true);
-    });
-
-    it("can get the keys", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.keys()).toEqual(["a", "c"]);
-    });
-
-    it("can get the values", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.values()).toEqual(["b", "d"]);
-    });
-
-    it("can get the entries", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.entries()).toEqual([
-        ["a", "b"],
-        ["c", "d"],
-      ]);
-    });
-
-    it("can get the all object", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.all()).toEqual({
-        a: "b",
-        c: "d",
-      });
-    });
-
-    it("can get the keys with a colon prefix", async () => {
-      await store.set("a:0", "a0");
-      await store.set("a:1", "a1");
-      await store.set("b:0", "b0");
-      await store.set("a:2", "a2");
-      expect((await store.keys()).sort()).toEqual(["a:0", "a:1", "a:2", "b:0"]);
-      expect((await store.prefix("a:").keys()).sort()).toEqual(["0", "1", "2"]);
-    });
-
-    it("can get the values with a colon prefix", async () => {
-      await store.set("a:0", "a0");
-      await store.set("a:1", "a1");
-      await store.set("b:0", "b0");
-      await store.set("a:2", "a2");
-      expect((await store.prefix("a:").values()).sort()).toEqual([
-        "a0",
-        "a1",
-        "a2",
-      ]);
-    });
-
-    it("can get the entries with a colon prefix", async () => {
-      await store.set("a:0", "a0");
-      await store.set("a:1", "a1");
-      await store.set("b:0", "b0");
-      await store.set("a:2", "a2");
-      expect((await store.entries()).sort()).toEqual([
-        ["a:0", "a0"],
-        ["a:1", "a1"],
-        ["a:2", "a2"],
-        ["b:0", "b0"],
-      ]);
-      expect((await store.prefix("a:").entries()).sort()).toEqual([
-        ["0", "a0"],
-        ["1", "a1"],
-        ["2", "a2"],
-      ]);
-    });
-
-    it("can get the all object with a colon prefix", async () => {
-      await store.set("a:0", "a0");
-      await store.set("a:1", "a1");
-      await store.set("b:0", "b0");
-      await store.set("a:2", "a2");
-      expect(await store.prefix("a:").all()).toEqual({
-        0: "a0",
-        1: "a1",
-        2: "a2",
-      });
-    });
-
-    it("can get the keys with a dash prefix", async () => {
-      await store.set("a-0", "a0");
-      await store.set("a-1", "a1");
-      await store.set("b-0", "b0");
-      await store.set("a-2", "a2");
-      expect((await store.keys()).sort()).toEqual(["a-0", "a-1", "a-2", "b-0"]);
-      expect((await store.prefix("a-").keys()).sort()).toEqual(["0", "1", "2"]);
-    });
-
-    it("can get the values with a dash prefix", async () => {
-      await store.set("a-0", "a0");
-      await store.set("a-1", "a1");
-      await store.set("b-0", "b0");
-      await store.set("a-2", "a2");
-      expect((await store.prefix("a-").values()).sort()).toEqual([
-        "a0",
-        "a1",
-        "a2",
-      ]);
-    });
-
-    it("can get the entries with a dash prefix", async () => {
-      await store.set("a-0", "a0");
-      await store.set("a-1", "a1");
-      await store.set("b-0", "b0");
-      await store.set("a-2", "a2");
-      expect((await store.prefix("a-").entries()).sort()).toEqual([
-        ["0", "a0"],
-        ["1", "a1"],
-        ["2", "a2"],
-      ]);
-    });
-
-    it("can get the all object with a dash prefix", async () => {
-      await store.set("a-0", "a0");
-      await store.set("a-1", "a1");
-      await store.set("b-0", "b0");
-      await store.set("a-2", "a2");
-      expect(await store.prefix("a-").all()).toEqual({
-        0: "a0",
-        1: "a1",
-        2: "a2",
-      });
-    });
-
-    it("can delete the data", async () => {
-      await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-      await store.del("a");
-      expect(await store.get("a")).toBe(null);
-      expect(await store.keys()).toEqual([]);
-    });
-
-    it("can delete the data by setting it to null", async () => {
-      await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-      await store.set("a", null);
-      expect(await store.get("a")).toBe(null);
-      expect(await store.keys()).toEqual([]);
-    });
-
-    it("can clear all the values", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.get("a")).toBe("b");
-      await store.clear();
-      expect(await store.get("a")).toBe(null);
-      await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-    });
-
-    describe("iteration", () => {
-      beforeEach(async () => {
-        await store.clear();
-      });
-
-      it("supports raw iteration", async () => {
-        await store.set("a", "b");
-        await store.set("c", "d");
-
-        const entries = [];
-        for await (const entry of store) {
-          entries.push(entry);
-        }
-        expect(entries).toEqual([
-          ["a", "b"],
-          ["c", "d"],
-        ]);
-      });
-
-      it("supports raw prefix iteration", async () => {
-        await store.set("a:a", "b");
-        await store.set("b:a", "d");
-        await store.set("a:c", "d");
-        await store.set("b:c", "d");
-
-        const entries = [];
-        for await (const entry of store.prefix("a:")) {
-          entries.push(entry);
-        }
-        expect(entries.sort()).toEqual([
-          ["a", "b"],
-          ["c", "d"],
-        ]);
-      });
-    });
-
-    describe("expires", () => {
-      // The mock implementation does NOT support expiration 😪
-      if (name === "kv(new KVNamespace())") return;
-
-      afterEach(() => {
-        jest.restoreAllMocks();
-      });
-
-      it("expires = 0 means immediately", async () => {
-        await store.set("a", "b", { expires: 0 });
-        expect(await store.get("a")).toBe(null);
-        expect(await store.has("a")).toBe(false);
-        expect(await store.keys()).toEqual([]);
-        expect(await store.values()).toEqual([]);
-        expect(await store.entries()).toEqual([]);
-      });
-
-      it("expires = potato means undefined = forever", async () => {
-        await store.set("a", "b", { expires: "potato" });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = 5potato means undefined = forever", async () => {
-        await store.set("a", "b", { expires: "5potato" });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = null means never to expire it", async () => {
-        await store.set("a", "b", { expires: null });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = undefined means never to expire it", async () => {
-        await store.set("a", "b");
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      if (
-        name !== `kv("cookie")` &&
-        name !== `kv(redis)` &&
-        name !== `kv(new Etcd3())`
-      ) {
-        it("can use 0.01 expire", async () => {
-          // 10ms
-          await store.set("a", "b", { expires: 0.01 });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(100);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-
-        it("can use 0.01s expire", async () => {
-          await store.set("a", "b", { expires: "0.01s" });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(100);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-
-        it("can use 0.01seconds expire", async () => {
-          await store.set("a", "b", { expires: "0.01seconds" });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(100);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-
-        it("can use 10ms expire", async () => {
-          await store.set("a", "b", { expires: "10ms" });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(100);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-
-        it("removes the expired key with .get()", async () => {
-          await store.set("a", "b", { expires: "10ms" });
-          const spy = jest.spyOn(store, "del");
-          expect(spy).not.toHaveBeenCalled();
-          await delay(100);
-          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
-          expect(await store.get("a")).toBe(null);
-          expect(spy).toHaveBeenCalled();
-        });
-
-        it("removes the expired key with .keys()", async () => {
-          await store.set("a", "b", { expires: "10ms" });
-          const spy = jest.spyOn(store, "del");
-          expect(spy).not.toHaveBeenCalled();
-          await delay(100);
-          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
-          expect(await store.keys()).toEqual([]);
-          expect(spy).toHaveBeenCalled();
-        });
-
-        it("CANNOT remove the expired key with .values()", async () => {
-          await store.set("a", "b", { expires: "10ms" });
-          const spy = jest.spyOn(store, "del");
-          expect(spy).not.toHaveBeenCalled();
-          await delay(100);
-          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
-          expect(await store.values()).toEqual([]);
-          if (!store.client.EXPIRES && store.client.values) {
-            expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪😪
-          } else {
-            expect(spy).toHaveBeenCalled();
-          }
-        });
-      } else {
-        it("can use 1 (second) expire", async () => {
-          await store.set("a", "b", { expires: 1 });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(2000);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-        it("can use 1s expire", async () => {
-          await store.set("a", "b", { expires: "1s" });
-          expect(await store.keys()).toEqual(["a"]);
-          expect(await store.values()).toEqual(["b"]);
-          expect(await store.get("a")).toBe("b");
-          await delay(2000);
-          expect(await store.keys()).toEqual([]);
-          expect(await store.values()).toEqual([]);
-          expect(await store.get("a")).toBe(null);
-        });
-      }
-    });
-
-    describe(".prefix()", () => {
-      let session;
-      beforeAll(() => {
-        session = store.prefix("session:");
-      });
-
-      it("has the same methods", () => {
-        expect(Object.keys(store)).toEqual(Object.keys(session));
-      });
-
-      it("can write/read one", async () => {
-        const id = await session.set("a", "b");
-        expect(id).toBe("a");
-        expect(await session.get("a")).toBe("b");
-        expect(await store.get("session:a")).toBe("b");
-      });
-
-      it("checks the has properly", async () => {
-        expect(await session.has("a")).toBe(false);
-        await session.set("a", "b");
-        expect(await session.has("a")).toBe(true);
-      });
-
-      it("can add with the prefix", async () => {
-        const id = await session.add("b");
-        expect(id.length).toBe(24);
-        expect(id).not.toMatch(/^session\:/);
-
-        const keys = await store.keys();
-        expect(keys[0]).toMatch(/^session\:/);
-      });
-
-      it("the group operations return the proper values", async () => {
-        await session.set("a", "b");
-
-        expect(await session.keys()).toEqual(["a"]);
-        expect(await session.values()).toEqual(["b"]);
-        expect(await session.entries()).toEqual([["a", "b"]]);
-
-        expect(await store.keys()).toEqual(["session:a"]);
-        expect(await store.values()).toEqual(["b"]);
-        expect(await store.entries()).toEqual([["session:a", "b"]]);
-      });
-
-      it("clears only the substore", async () => {
-        await store.set("a", "b");
-        await session.set("c", "d");
-
-        expect((await store.keys()).sort()).toEqual(["a", "session:c"]);
-        await session.clear();
-        expect(await store.keys()).toEqual(["a"]);
-      });
-    });
-
-    describe(".prefix().prefix()", () => {
-      let auth;
-      beforeAll(() => {
-        auth = store.prefix("session:").prefix("auth:");
-      });
-
-      it("can write/read one", async () => {
-        const id = await auth.set("a", "b");
-        expect(id).toBe("a");
-        expect(await auth.get("a")).toBe("b");
-        expect(await store.get("session:auth:a")).toBe("b");
-      });
-
-      it("can add with the prefix", async () => {
-        const id = await auth.add("b");
-        expect(id.length).toBe(24);
-        expect(id).not.toMatch(/^session\:/);
-
-        const keys = await store.keys();
-        expect(keys[0]).toMatch(/^session\:auth\:/);
-      });
-
-      it("the group operations return the proper values", async () => {
-        await auth.set("a", "b");
-
-        expect(await auth.keys()).toEqual(["a"]);
-        expect(await auth.values()).toEqual(["b"]);
-        expect(await auth.entries()).toEqual([["a", "b"]]);
-
-        expect(await store.keys()).toEqual(["session:auth:a"]);
-        expect(await store.values()).toEqual(["b"]);
-        expect(await store.entries()).toEqual([["session:auth:a", "b"]]);
-      });
-
-      it("clears only the substore", async () => {
-        await store.set("a", "b");
-        await auth.set("c", "d");
-
-        expect((await store.keys()).sort()).toEqual(["a", "session:auth:c"]);
-        await auth.clear();
-        expect(await store.keys()).toEqual(["a"]);
-      });
-    });
-  });
-}

package/src/index.types.ts

@@ -1,18 +0,0 @@
-import kv from "..";
-
-const store = kv();
-
-(async () => {
-  await store.get("key");
-  await store.set("key", "value");
-  await store.set("key", "value", {});
-  await store.set("key", "value", { expires: 100 });
-  await store.set("key", "value", { expires: "100s" });
-  await store.prefix("a:").prefix("b:").get("hello");
-  const key1: string = await store.add("value");
-  const key2: string = await store.add("value", { expires: 100 });
-  const key3: string = await store.add("value", { expires: "100s" });
-  console.log(key1, key2, key3);
-  if (await store.has("key")) {
-  }
-})();

package/src/test/customFull.js

@@ -1,45 +0,0 @@
-const dataSource = {};
-
-export default class MyClient {
-  get(key) {
-    return dataSource[key];
-  }
-
-  set(key, value) {
-    dataSource[key] = value;
-  }
-
-  add(prefix, value) {
-    const id = Math.random().toString(16).slice(2).padStart(24, "0");
-    this.set(prefix + id, value);
-    return id;
-  }
-
-  del(key) {
-    delete dataSource[key];
-  }
-
-  *iterate(prefix) {
-    const entries = this.entries(prefix);
-    for (const entry of entries) {
-      yield entry;
-    }
-  }
-
-  // Filter them by the prefix, note that `prefix` will always be a string
-  entries(prefix) {
-    const entries = Object.entries(dataSource);
-    if (!prefix) return entries;
-    return entries.filter(([key]) => key.startsWith(prefix));
-  }
-
-  values(prefix) {
-    const list = this.entries(prefix);
-    return list.map((e) => e[1]);
-  }
-
-  // Cannot have a keys() if it's an unamanaged store
-  // keys(prefix) {
-  //   // This should throw
-  // }
-}

package/src/test/customSimple.js

@@ -1,27 +0,0 @@
-const dataSource = {};
-
-export default class MyClient {
-  get(key) {
-    return dataSource[key];
-  }
-
-  // No need to stringify it or anything for a plain object storage
-  set(key, value) {
-    if (value === null) {
-      delete dataSource[key];
-    } else {
-      dataSource[key] = value;
-    }
-  }
-
-  // Filter them by the prefix, note that `prefix` will always be a string
-  *iterate(prefix) {
-    const raw = Object.entries(dataSource);
-    const entries = prefix
-      ? raw.filter(([key, value]) => key.startsWith(prefix))
-      : raw;
-    for (const entry of entries) {
-      yield entry;
-    }
-  }
-}

package/src/test/data.json

@@ -1 +0,0 @@
-{}

package/src/test/setup.js

@@ -1,23 +0,0 @@
-import * as util from "util";
-
-// ref: https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
-// ref: https://github.com/jsdom/jsdom/issues/2524
-if (typeof TextEncoder === "undefined") {
-  Object.defineProperty(window, "TextEncoder", {
-    writable: true,
-    value: util.TextEncoder,
-  });
-}
-if (typeof TextDecoder === "undefined") {
-  Object.defineProperty(window, "TextDecoder", {
-    writable: true,
-    value: util.TextDecoder,
-  });
-}
-
-if (typeof setImmediate === "undefined") {
-  Object.defineProperty(window, "setImmediate", {
-    writable: true,
-    value: (cb) => setTimeout(cb, 0),
-  });
-}