@weborigami/async-tree 0.5.7 → 0.6.0

package/test/drivers/ObjectMap.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import * as symbols from "../../src/symbols.js";
+
+describe("ObjectMap", () => {
+  test("can get the keys of the tree", () => {
+    const fixture = createFixture();
+    assert.deepEqual(Array.from(fixture.keys()), [
+      "Alice.md",
+      "Bob.md",
+      "Carol.md",
+    ]);
+  });
+
+  test("can get the value for a key", () => {
+    const map = createFixture();
+    const alice = map.get("Alice.md");
+    assert.equal(alice, "Hello, **Alice**.");
+  });
+
+  test("getting an unsupported key returns undefined", () => {
+    const map = createFixture();
+    assert.equal(map.get("xyz"), undefined);
+  });
+
+  test("getting a null/undefined key throws an exception", async () => {
+    const map = createFixture();
+    await assert.rejects(async () => {
+      map.get(null);
+    });
+    await assert.rejects(async () => {
+      map.get(undefined);
+    });
+  });
+
+  test("can set a value", () => {
+    const map = new ObjectMap({
+      a: 1,
+      b: 2,
+      c: 3,
+    });
+
+    // Update existing key
+    map.set("a", 4);
+
+    // Delete key
+    map.delete("b");
+
+    // Overwrite key with trailing slash
+    map.set("c/", {});
+
+    // New key
+    map.set("d", 5);
+
+    const entries = Array.from(map.entries());
+    assert.deepEqual(entries, [
+      ["a", 4],
+      ["c/", {}],
+      ["d", 5],
+    ]);
+  });
+
+  test("can wrap a class instance", () => {
+    class Foo {
+      constructor() {
+        this.a = 1;
+      }
+
+      get prop() {
+        return this._prop;
+      }
+      set prop(prop) {
+        this._prop = prop;
+      }
+    }
+    class Bar extends Foo {
+      method() {}
+    }
+    const bar = new Bar();
+    /** @type {any} */ (bar).extra = "Hello";
+
+    const map = new ObjectMap(bar);
+    const entries = Array.from(map.entries());
+    assert.deepEqual(entries, [
+      ["a", 1],
+      ["extra", "Hello"],
+      ["prop", undefined],
+    ]);
+    assert.equal(map.get("a"), 1);
+    map.set("prop", "Goodbye");
+    assert.equal(bar.prop, "Goodbye");
+    assert.equal(map.get("prop"), "Goodbye");
+  });
+
+  test("sets parent symbol on subobjects", () => {
+    const map = new ObjectMap({
+      sub: {},
+    });
+    const sub = map.get("sub");
+    assert.equal(sub[symbols.parent], map);
+  });
+
+  test("sets parent on subtrees", () => {
+    const map = new ObjectMap({
+      a: 1,
+      more: new ObjectMap({
+        b: 2,
+      }),
+    });
+    const more = map.get("more");
+    assert.equal(more.parent, map);
+  });
+
+  test("adds trailing slashes to keys for subtrees", () => {
+    const map = new ObjectMap({
+      a1: 1,
+      a2: new ObjectMap({
+        b1: 2,
+      }),
+      a3: 3,
+      a4: new ObjectMap({
+        b2: 4,
+      }),
+    });
+    const keys = Array.from(map.keys());
+    assert.deepEqual(keys, ["a1", "a2/", "a3", "a4/"]);
+  });
+
+  test("can retrieve values with optional trailing slash", () => {
+    const subMap = {
+      get(key) {},
+      keys() {},
+    };
+    const map = new ObjectMap({
+      a: 1,
+      subMap,
+    });
+    assert.equal(map.get("a"), 1);
+    assert.equal(map.get("a/"), 1);
+    assert.equal(map.get("subMap"), subMap);
+    assert.equal(map.get("subMap/"), subMap);
+  });
+
+  test("method on an object is bound to the object", () => {
+    const n = new Number(123);
+    const map = new ObjectMap(n);
+    const method = map.get("toString");
+    assert.equal(method(), "123");
+  });
+
+  test("defers to symbols.keys for keys if defined", () => {
+    const map = new ObjectMap({
+      [symbols.keys]: () => ["a", "b", "c"],
+    });
+    assert.deepEqual(Array.from(map.keys()), ["a", "b", "c"]);
+  });
+});
+
+function createFixture() {
+  return new ObjectMap({
+    "Alice.md": "Hello, **Alice**.",
+    "Bob.md": "Hello, **Bob**.",
+    "Carol.md": "Hello, **Carol**.",
+  });
+}

package/test/drivers/SetMap.test.js

@@ -0,0 +1,35 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import SetMap from "../../src/drivers/SetMap.js";
+
+describe("SetMap", () => {
+  test("can get the keys of the map", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    assert.deepEqual(Array.from(await fixture.keys()), ["a", "b", "c"]);
+  });
+
+  test("can get the value for a key", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    const a = await fixture.get("a");
+    assert.equal(a, "a");
+  });
+
+  test("getting an unsupported key returns undefined", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    assert.equal(await fixture.get("d"), undefined);
+  });
+
+  test("getting a null/undefined key throws an exception", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    await assert.rejects(async () => {
+      await fixture.get(null);
+    });
+    await assert.rejects(async () => {
+      await fixture.get(undefined);
+    });
+  });
+});

package/test/drivers/{SiteTree.test.js → SiteMap.test.js}

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
-import SiteTree from "../../src/drivers/SiteTree.js";
+import SiteMap from "../../src/drivers/SiteMap.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -27,38 +27,42 @@ const mockResponses = {
   },
 };
 
-describe("SiteTree", () => {
+describe("SiteMap", () => {
   beforeEach(() => {
     mock.method(global, "fetch", mockFetch);
   });
 
   test("returns an empty array as the keys of a tree", async () => {
-    const fixture = new SiteTree(mockHost);
-    const keys = await fixture.keys();
-    assert.deepEqual(Array.from(keys), []);
+    const fixture = new SiteMap(mockHost);
+    const keys = [];
+    for await (const key of fixture.keys()) {
+      keys.push(key);
+    }
+    assert.deepEqual(keys, []);
   });
 
   test("can get a plain value for a key", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
+    /** @type {any} */
     const arrayBuffer = await fixture.get("index.html");
     const text = textDecoder.decode(arrayBuffer);
     assert.equal(text, "Home page");
   });
 
   test("immediately return a new tree for a key with a trailing slash", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     const about = await fixture.get("about/");
-    assert(about instanceof SiteTree);
+    assert(about instanceof SiteMap);
     assert.equal(about.href, "https://mock/about/");
   });
 
   test("getting an unsupported key returns undefined", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     assert.equal(await fixture.get("xyz"), undefined);
   });
 
   test("getting a null/undefined key throws an exception", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     await assert.rejects(async () => {
       await fixture.get(null);
     });

package/test/drivers/SyncMap.test.js

@@ -0,0 +1,321 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import SyncMap from "../../src/drivers/SyncMap.js";
+
+describe("SyncMap", () => {
+  test("passes instanceof Map", () => {
+    const map = new SyncMap();
+    assert(map instanceof Map);
+  });
+
+  test("can be constructed with an iterable", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    assert.strictEqual(map.size, 2);
+    assert.strictEqual(map.get("a"), 1);
+    assert.strictEqual(map.get("b"), 2);
+  });
+
+  test("can be constructed with another SyncMap", () => {
+    const map1 = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const map2 = new SyncMap(map1);
+    const entries = Array.from(map2.entries());
+    assert.deepStrictEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+    ]);
+  });
+
+  test("clear calls delete for each key", () => {
+    const deletedKeys = [];
+    const keys = ["a", "b", "c"];
+    class Fixture extends SyncMap {
+      delete(key) {
+        deletedKeys.push(key);
+        return keys.includes(key);
+      }
+
+      keys() {
+        return keys[Symbol.iterator]();
+      }
+    }
+    const map = new Fixture();
+    map.clear();
+    assert.deepStrictEqual(deletedKeys, ["a", "b", "c"]);
+  });
+
+  test("delete", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    assert.strictEqual(map.size, 2);
+    assert.strictEqual(map.delete("a"), true);
+    assert.strictEqual(map.size, 1);
+    assert.strictEqual(map.get("a"), undefined);
+    assert.strictEqual(map.delete("a"), false);
+    assert.strictEqual(map.size, 1);
+  });
+
+  test("delete on read-only map throws", () => {
+    class Fixture extends SyncMap {
+      get(key) {
+        return super.get(key);
+      }
+    }
+    const map = new Fixture([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    assert.throws(() => map.delete("a"), {
+      name: "TypeError",
+      message: "delete() can't be called on a read-only map",
+    });
+  });
+
+  test("entries", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const entries = Array.from(map.entries());
+    assert.deepStrictEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+    ]);
+  });
+
+  test("forEach", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const calls = [];
+    map.forEach((value, key, theMap) => {
+      calls.push([key, value, theMap]);
+    });
+    assert.deepStrictEqual(calls, [
+      ["a", 1, map],
+      ["b", 2, map],
+    ]);
+  });
+
+  test("get", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    assert.strictEqual(map.get("a"), 1);
+    assert.strictEqual(map.get("b"), 2);
+    assert.strictEqual(map.get("c"), undefined);
+  });
+
+  test("get with trailing slash", () => {
+    const subMap = new SyncMap();
+    const map = new SyncMap([
+      ["a", 1],
+      ["b/", subMap],
+    ]);
+    assert.strictEqual(map.get("a"), 1);
+
+    const b = map.get("b/");
+    assert.strictEqual(b, subMap);
+    assert.strictEqual(b.parent, map);
+
+    // Trailing slash optional
+    assert.strictEqual(map.get("b"), subMap);
+
+    assert.strictEqual(map.get("c"), undefined);
+  });
+
+  test("has returns true if key exists in keys()", () => {
+    const map = new SyncMap();
+    map.keys = () => {
+      return ["a", "b/"][Symbol.iterator]();
+    };
+    assert.strictEqual(map.has("a"), true);
+    assert.strictEqual(map.has("b"), true); // trailing slash optional
+    assert.strictEqual(map.has("b/"), true);
+    assert.strictEqual(map.has("c"), false);
+  });
+
+  test("readOnly if get() is overridden but not delete() and set()", () => {
+    const map4 = new SyncMap();
+    assert.strictEqual(map4.readOnly, false);
+
+    class ReadOnly1 extends SyncMap {
+      get(key) {
+        return super.get(key);
+      }
+    }
+    const map1 = new ReadOnly1();
+    assert.strictEqual(map1.readOnly, true);
+
+    class ReadOnly2 extends SyncMap {
+      get(key) {
+        return super.get(key);
+      }
+      set(key, value) {
+        return super.set(key, value);
+      }
+    }
+    const map2 = new ReadOnly2();
+    assert.strictEqual(map2.readOnly, true);
+
+    class ReadWrite extends SyncMap {
+      get(key) {
+        return super.get(key);
+      }
+      set(key, value) {
+        return super.set(key, value);
+      }
+      delete(key) {
+        return super.delete(key);
+      }
+    }
+    const map3 = new ReadWrite();
+    assert.strictEqual(map3.readOnly, false);
+  });
+
+  test("Symbol.iterator", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const entries = Array.from(map[Symbol.iterator]());
+    assert.deepStrictEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+    ]);
+  });
+
+  test("keys", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const keys = Array.from(map.keys());
+    assert.deepStrictEqual(keys, ["a", "b"]);
+  });
+
+  test("set", () => {
+    const map = new SyncMap();
+    assert.strictEqual(map.size, 0);
+    map.set("a", 1);
+    assert.strictEqual(map.size, 1);
+    assert.strictEqual(map.get("a"), 1);
+    map.set("a", 2);
+    assert.strictEqual(map.size, 1);
+    assert.strictEqual(map.get("a"), 2);
+    map.set("b", 3);
+    assert.strictEqual(map.size, 2);
+    assert.strictEqual(map.get("b"), 3);
+  });
+
+  test("set with EMPTY value creates empty subtree", () => {
+    const map = new SyncMap();
+    map.set("subtree", SyncMap.EMPTY);
+    const subtree = map.get("subtree");
+    assert(subtree instanceof SyncMap);
+    assert.strictEqual(subtree.size, 0);
+  });
+
+  test("set on read-only map throws", () => {
+    class Fixture extends SyncMap {
+      get(key) {
+        return super.get(key);
+      }
+    }
+    const map = new Fixture();
+    assert.throws(() => map.set("a", 1), {
+      name: "TypeError",
+      message: "set() can't be called on a read-only map",
+    });
+  });
+
+  test("size", () => {
+    const map = new SyncMap();
+    assert.strictEqual(map.size, 0);
+    map.set("a", 1);
+    assert.strictEqual(map.size, 1);
+    map.set("b", 2);
+    assert.strictEqual(map.size, 2);
+    map.delete("a");
+    assert.strictEqual(map.size, 1);
+    map.clear();
+    assert.strictEqual(map.size, 0);
+  });
+
+  test("values", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const values = Array.from(map.values());
+    assert.deepStrictEqual(values, [1, 2]);
+  });
+
+  test("all methods work with prototype chain extension", () => {
+    const map = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const map2 = Object.create(map);
+    assert.strictEqual(map2.get("a"), 1);
+    assert.strictEqual(map2.has("b"), true);
+    assert.strictEqual(map2.size, 2);
+
+    const entries = Array.from(map2.entries());
+    assert.deepStrictEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+    ]);
+
+    const keys = Array.from(map2.keys());
+    assert.deepStrictEqual(keys, ["a", "b"]);
+
+    const values = Array.from(map2.values());
+    assert.deepStrictEqual(values, [1, 2]);
+
+    const iteratedEntries = Array.from(map2[Symbol.iterator]());
+    assert.deepStrictEqual(iteratedEntries, [
+      ["a", 1],
+      ["b", 2],
+    ]);
+
+    const forEachCalls = [];
+    map2.forEach((value, key, thisArg) => {
+      forEachCalls.push([key, value, thisArg]);
+    });
+    assert.deepStrictEqual(forEachCalls, [
+      ["a", 1, map2],
+      ["b", 2, map2],
+    ]);
+  });
+
+  if ("groupBy" in Map) {
+    test("acceptable to Map.groupBy", () => {
+      const map = new SyncMap([
+        ["a", 1],
+        ["b", 2],
+        ["c", 3],
+      ]);
+      // @ts-ignore
+      const grouped = Map.groupBy(map, ([key, value]) =>
+        value % 2 === 0 ? "even" : "odd"
+      );
+      assert(grouped instanceof Map);
+      assert.strictEqual(grouped.size, 2);
+      assert.deepStrictEqual(grouped.get("odd"), [
+        ["a", 1],
+        ["c", 3],
+      ]);
+      assert.deepStrictEqual(grouped.get("even"), [["b", 2]]);
+    });
+  }
+});

package/test/jsonKeys.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../src/drivers/DeepObjectTree.js";
+import DeepObjectMap from "../src/drivers/DeepObjectMap.js";
 import * as jsonKeys from "../src/jsonKeys.js";
 
 describe("jsonKeys", () => {
   test("stringifies JSON Keys", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       about: {},
       "index.html": "Home",
     });

package/test/operations/addNextPrevious.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import addNextPrevious from "../../src/operations/addNextPrevious.js";
+import plain from "../../src/operations/plain.js";
 
 describe("addNextPrevious", () => {
   test("adds next/previous properties to values", async () => {
@@ -16,7 +17,7 @@ describe("addNextPrevious", () => {
       },
     };
     const result = await addNextPrevious(tree);
-    assert.deepEqual(result, {
+    assert.deepEqual(await plain(result), {
       alice: {
         name: "Alice",
         nextKey: "bob",
@@ -36,7 +37,7 @@ describe("addNextPrevious", () => {
   test("returns a non-object value as a 'value' property", async () => {
     const array = ["Alice", "Bob", "Carol"];
     const result = await addNextPrevious(array);
-    assert.deepEqual(result, [
+    assert.deepEqual(await plain(result), [
       {
         value: "Alice",
         nextKey: "1",