@weborigami/async-tree 0.5.8 → 0.6.1

package/test/drivers/SyncMap.test.js

@@ -0,0 +1,335 @@
+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("child creates new map when not present", () => {
+    // Create child when not present
+    const map = new SyncMap();
+    const child1 = map.child("sub");
+    assert(child1 instanceof SyncMap);
+    const stored1 = map.get("sub");
+    assert.strictEqual(stored1, child1);
+
+    // Return existing child
+    const child2 = map.child("sub");
+    assert.strictEqual(child2, child1);
+  });
+
+  test("child overwrites non-map value", () => {
+    const map = new SyncMap();
+    map.set("sub", 123);
+    const child = map.child("sub");
+    assert(child instanceof SyncMap);
+    const stored = map.get("sub");
+    assert.strictEqual(stored, child);
+  });
+
+  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,14 +1,26 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../src/drivers/DeepObjectTree.js";
+import ObjectMap from "../src/drivers/ObjectMap.js";
 import * as jsonKeys from "../src/jsonKeys.js";
 
 describe("jsonKeys", () => {
-  test("stringifies JSON Keys", async () => {
-    const tree = new DeepObjectTree({
-      about: {},
-      "index.html": "Home",
-    });
+  test("creates JSON keys for a simple map", async () => {
+    const tree = new /** @type {any} */ (Map)([
+      ["index.html", "Home"],
+      ["about", new Map()],
+    ]);
+    const json = await jsonKeys.stringify(tree);
+    assert.strictEqual(json, '["index.html","about/"]');
+  });
+
+  test("creates JSON keys for a map that supports trailing slashes", async () => {
+    const tree = new ObjectMap(
+      {
+        about: {},
+        "index.html": "Home",
+      },
+      { deep: true }
+    );
     const json = await jsonKeys.stringify(tree);
     assert.strictEqual(json, '["about/","index.html"]');
   });

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",

package/test/operations/assign.test.js

@@ -1,53 +1,48 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../../src/drivers/DeepObjectTree.js";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import SyncMap from "../../src/drivers/SyncMap.js";
 import assign from "../../src/operations/assign.js";
 import plain from "../../src/operations/plain.js";
+import { deepEntries } from "../../src/Tree.js";
+import SampleAsyncMap from "../SampleAsyncMap.js";
 
 describe("assign", () => {
-  test("assign applies one tree to another", async () => {
-    const target = new DeepObjectTree({
-      a: 1,
-      b: 2,
-      more: {
-        d: 3,
-      },
-    });
+  test("assign can apply updates from an async tree to a sync tree", async () => {
+    const target = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+      ["more", new SyncMap([["d", 3]])],
+    ]);
 
-    const source = new DeepObjectTree({
-      a: 4, // Overwrite existing value
-      b: undefined, // Delete
-      c: 5, // Add
-      more: {
-        // Should leave existing `more` keys alone.
-        e: 6, // Add
-      },
-      // Add new subtree
-      extra: {
-        f: 7,
-      },
-    });
+    const source = new SampleAsyncMap([
+      ["a", 4], // Overwrite existing value
+      ["c", 5], // Add
+      ["more", [["e", 6]]], // Should leave existing `more` keys alone.
+      ["extra", [["f", 7]]], // Add new subtree
+    ]);
 
     // Apply changes.
     const result = await assign(target, source);
 
     assert.equal(result, target);
-    assert.deepEqual(await plain(target), {
-      a: 4,
-      c: 5,
-      more: {
-        d: 3,
-        e: 6,
-      },
-      extra: {
-        f: 7,
-      },
-    });
+    assert.deepEqual(await deepEntries(target), [
+      ["a", 4],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["d", 3],
+          ["e", 6],
+        ],
+      ],
+      ["c", 5],
+      ["extra", [["f", 7]]],
+    ]);
   });
 
   test("assign() can apply updates to an array", async () => {
-    const target = new ObjectTree(["a", "b", "c"]);
+    const target = new ObjectMap(["a", "b", "c"]);
     await assign(target, ["d", "e"]);
     assert.deepEqual(await plain(target), ["d", "e", "c"]);
   });

package/test/operations/cache.test.js

@@ -1,25 +1,30 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import SyncMap from "../../src/drivers/SyncMap.js";
 import cache from "../../src/operations/cache.js";
+import keys from "../../src/operations/keys.js";
 
 describe("cache", () => {
   test("caches reads of values from one tree into another", async () => {
-    const objectCache = new ObjectTree({});
+    const objectCache = new SyncMap();
     const fixture = await cache(
-      new DeepObjectTree({
-        a: 1,
-        b: 2,
-        c: 3,
-        more: {
-          d: 4,
+      new ObjectMap(
+        {
+          a: 1,
+          b: 2,
+          c: 3,
+          more: {
+            d: 4,
+          },
         },
-      }),
+        { deep: true }
+      ),
       objectCache
     );
 
-    const keys = [...(await fixture.keys())];
-    assert.deepEqual(keys, ["a", "b", "c", "more/"]);
+    const treeKeys = await keys(fixture);
+    assert.deepEqual(treeKeys, ["a", "b", "c", "more/"]);
 
     assert.equal(await objectCache.get("a"), undefined);
     assert.equal(await fixture.get("a"), 1);
@@ -31,7 +36,7 @@ describe("cache", () => {
 
     assert.equal(await objectCache.get("more"), undefined);
     const more = await fixture.get("more");
-    assert.deepEqual([...(await more.keys())], ["d"]);
+    assert.deepEqual([...(await keys(more))], ["d"]);
     assert.equal(await more.get("d"), 4);
     const moreCache = await objectCache.get("more");
     assert.equal(await moreCache.get("d"), 4);

package/test/operations/cachedKeyFunctions.test.js

@@ -1,12 +1,12 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import cachedKeyFunctions from "../../src/operations/cachedKeyFunctions.js";
 import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("cachedKeyFunctions", () => {
   test("maps keys with caching", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
       b: "letter b",
     });
@@ -41,12 +41,15 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("maps keys with caching and deep option", async () => {
-    const tree = new DeepObjectTree({
-      a: "letter a",
-      b: {
-        c: "letter c",
+    const tree = new ObjectMap(
+      {
+        a: "letter a",
+        b: {
+          c: "letter c",
+        },
       },
-    });
+      { deep: true }
+    );
 
     let callCount = 0;
     const addUnderscore = async (sourceValue, sourceKey, tree) => {
@@ -76,7 +79,7 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("preserves trailing slashes if key function does so", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
     });
     const addUnderscore = async (sourceValue, sourceKey) => `_${sourceKey}`;
@@ -90,7 +93,7 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("if key function toggles slash, defers to key function slash handling", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
     });
     const addUnderscoreAndSlash = async (sourceValue, sourceKey) =>

package/test/operations/child.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import child from "../../src/operations/child.js";
+
+describe("child", () => {
+  test("defers to map.child() if available", async () => {
+    class CustomMap extends Map {
+      child(key) {
+        return `child-${key}`;
+      }
+
+      parent = null;
+      trailingSlashKeys = false;
+    }
+    const map = new CustomMap();
+    const result = await child(map, "test");
+    assert.strictEqual(result, "child-test");
+  });
+
+  test("returns existing subtree if present", async () => {
+    const subtree = new Map();
+    const map = new Map([["sub", subtree]]);
+    const result = await child(map, "sub");
+    assert.strictEqual(result, subtree);
+  });
+
+  test("creates new subtree if not present", async () => {
+    const map = new Map();
+    const result = await child(map, "sub");
+    assert.ok(result instanceof Map);
+    const stored = await map.get("sub");
+    assert.strictEqual(stored, result);
+  });
+});

package/test/operations/clear.test.js

@@ -1,34 +1,13 @@
 import assert from "node:assert";
-import * as fs from "node:fs/promises";
-import path from "node:path";
 import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
-import FileTree from "../../src/drivers/FileTree.js";
-import { ObjectTree, Tree } from "../../src/internal.js";
-
-const dirname = path.dirname(fileURLToPath(import.meta.url));
-const tempDirectory = path.join(dirname, "fixtures/temp");
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import clear from "../../src/operations/clear.js";
+import plain from "../../src/operations/plain.js";
 
 describe("clear", () => {
   test("unsets all public keys in an object tree", async () => {
-    const tree = new ObjectTree({ a: 1, b: 2, c: 3 });
-    await Tree.clear(tree);
-    assert.deepEqual(await Tree.plain(tree), {});
-  });
-
-  test("unsets all public keys in a file tree", async () => {
-    // Create a temp directory with some files
-    await fs.mkdir(tempDirectory, { recursive: true });
-    await fs.writeFile(path.join(tempDirectory, "a"), "1");
-    await fs.writeFile(path.join(tempDirectory, "b"), "2");
-
-    const tree = new FileTree(tempDirectory);
-    await Tree.clear(tree);
-
-    const files = await fs.readdir(tempDirectory);
-    assert.deepEqual(files, []);
-
-    // Remove temp directory
-    await fs.rm(tempDirectory, { recursive: true });
+    const tree = new ObjectMap({ a: 1, b: 2, c: 3 });
+    await clear(tree);
+    assert.deepEqual(await plain(tree), {});
   });
 });

package/test/operations/deepEntries.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import deepEntries from "../../src/operations/deepEntries.js";
+import SampleAsyncMap from "../SampleAsyncMap.js";
+
+describe("deepEntries", () => {
+  test("converts an async tree to an array of nested entries arrays", async () => {
+    const fixture = new SampleAsyncMap([
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+    const result = await deepEntries(fixture);
+    assert.deepStrictEqual(result, [
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+  });
+});