@weborigami/async-tree 0.6.0 → 0.6.1

package/test/drivers/FileMap.test.js

@@ -4,8 +4,6 @@ import path from "node:path";
 import { describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
 import FileMap from "../../src/drivers/FileMap.js";
-import map from "../../src/operations/map.js";
-import plain from "../../src/operations/plain.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const tempDirectory = path.join(dirname, "fixtures/temp");
@@ -82,12 +80,12 @@ describe("FileMap", () => {
     removeTempDirectory();
   });
 
-  test("create subfolder via set() with EMPTY", () => {
+  test("create subfolder via child()", () => {
     createTempDirectory();
 
     // Write out new, empty folder called "empty".
     const tempFiles = new FileMap(tempDirectory);
-    tempFiles.set("empty", FileMap.EMPTY);
+    tempFiles.child("empty");
 
     // Verify folder exists and has no contents.
     const folderPath = path.join(tempDirectory, "empty");
@@ -99,33 +97,6 @@ describe("FileMap", () => {
     removeTempDirectory();
   });
 
-  test("can write out subfolder via set()", async () => {
-    createTempDirectory();
-
-    // Create a tiny set of "files".
-    // @ts-ignore
-    const files = new Map([
-      ["file1", "This is the first file."],
-      ["subfolder", new Map([["file2", "This is the second file."]])],
-    ]);
-    const object = await plain(files);
-
-    // Write out files as a new folder called "folder".
-    const tempFiles = new FileMap(tempDirectory);
-    tempFiles.set("folder", files);
-
-    // Read them back in.
-    const actualFiles = tempFiles.get("folder");
-    const strings = await map(actualFiles, {
-      deep: true,
-      value: (buffer) => textDecoder.decode(buffer),
-    });
-    const result = await plain(strings);
-    assert.deepEqual(result, object);
-
-    removeTempDirectory();
-  });
-
   test("can delete a file", () => {
     createTempDirectory();
     const tempFile = path.join(tempDirectory, "file");

package/test/drivers/ObjectMap.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import ObjectMap from "../../src/drivers/ObjectMap.js";
+import plain from "../../src/operations/plain.js";
 import * as symbols from "../../src/symbols.js";
 
 describe("ObjectMap", () => {
@@ -155,6 +156,33 @@ describe("ObjectMap", () => {
     });
     assert.deepEqual(Array.from(map.keys()), ["a", "b", "c"]);
   });
+
+  test("deep option treats sub-objects and sub-arrays as child nodes", async () => {
+    const map = new ObjectMap(
+      {
+        a: 1,
+        object: {
+          b: 2,
+        },
+        array: [3],
+      },
+      { deep: true }
+    );
+
+    // Adds trailing slashes to keys for sub-objects and sub-arrays
+    const keys = Array.from(await map.keys());
+    assert.deepEqual(keys, ["a", "object/", "array/"]);
+
+    const object = await map.get("object");
+    assert.equal(object instanceof ObjectMap, true);
+    assert.deepEqual(await plain(object), { b: 2 });
+    assert.equal(object.parent, map);
+
+    const array = await map.get("array");
+    assert.equal(array instanceof ObjectMap, true);
+    assert.deepEqual(await plain(array), [3]);
+    assert.equal(array.parent, map);
+  });
 });
 
 function createFixture() {

package/test/drivers/SyncMap.test.js

@@ -217,12 +217,26 @@ describe("SyncMap", () => {
     assert.strictEqual(map.get("b"), 3);
   });
 
-  test("set with EMPTY value creates empty subtree", () => {
+  test("child creates new map when not present", () => {
+    // Create child when not present
     const map = new SyncMap();
-    map.set("subtree", SyncMap.EMPTY);
-    const subtree = map.get("subtree");
-    assert(subtree instanceof SyncMap);
-    assert.strictEqual(subtree.size, 0);
+    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", () => {

package/test/jsonKeys.test.js

@@ -1,14 +1,26 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../src/drivers/DeepObjectMap.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 DeepObjectMap({
-      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/cache.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.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";
@@ -9,14 +9,17 @@ describe("cache", () => {
   test("caches reads of values from one tree into another", async () => {
     const objectCache = new SyncMap();
     const fixture = await cache(
-      new DeepObjectMap({
-        a: 1,
-        b: 2,
-        c: 3,
-        more: {
-          d: 4,
+      new ObjectMap(
+        {
+          a: 1,
+          b: 2,
+          c: 3,
+          more: {
+            d: 4,
+          },
         },
-      }),
+        { deep: true }
+      ),
       objectCache
     );
 

package/test/operations/cachedKeyFunctions.test.js

@@ -1,6 +1,5 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
 import ObjectMap from "../../src/drivers/ObjectMap.js";
 import cachedKeyFunctions from "../../src/operations/cachedKeyFunctions.js";
 import * as trailingSlash from "../../src/trailingSlash.js";
@@ -42,12 +41,15 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("maps keys with caching and deep option", async () => {
-    const tree = new DeepObjectMap({
-      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) => {

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/deepMerge.test.js

@@ -1,29 +1,35 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import deepMerge from "../../src/operations/deepMerge.js";
 import plain from "../../src/operations/plain.js";
 
 describe("mergeDeep", () => {
   test("can merge deep", async () => {
     const fixture = await deepMerge(
-      new DeepObjectMap({
-        a: {
-          b: 0, // Will be obscured by `b` below
-          c: {
-            d: 2,
+      new ObjectMap(
+        {
+          a: {
+            b: 0, // Will be obscured by `b` below
+            c: {
+              d: 2,
+            },
           },
         },
-      }),
-      new DeepObjectMap({
-        a: {
-          b: 1,
-          c: {
-            e: 3,
+        { deep: true }
+      ),
+      new ObjectMap(
+        {
+          a: {
+            b: 1,
+            c: {
+              e: 3,
+            },
+            f: 4,
           },
-          f: 4,
         },
-      })
+        { deep: true }
+      )
     );
     assert.deepEqual(await plain(fixture), {
       a: {

package/test/operations/from.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import SetMap from "../../src/drivers/SetMap.js";
 import from from "../../src/operations/from.js";
 import values from "../../src/operations/values.js";
@@ -23,7 +23,8 @@ describe("from", () => {
       },
     };
     const tree = from(obj, { deep: true });
-    assert(tree instanceof DeepObjectMap);
+    assert(tree instanceof ObjectMap);
+    assert(tree.deep);
   });
 
   test("returns a deep object map if object has [deep] symbol set", async () => {
@@ -34,7 +35,8 @@ describe("from", () => {
     };
     Object.defineProperty(obj, symbols.deep, { value: true });
     const tree = from(obj);
-    assert(tree instanceof DeepObjectMap);
+    assert(tree instanceof ObjectMap);
+    assert(tree.deep);
   });
 
   test("returns a SetMap for Set objects", async () => {
@@ -44,7 +46,7 @@ describe("from", () => {
     assert.deepEqual(await values(map), ["a", "b", "c"]);
   });
 
-  test.only("returns an array for an Iterator", async () => {
+  test("returns an array for an Iterator", async () => {
     const set = new Set(["a", "b", "c"]);
     const map = from(set.values());
     assert.deepEqual(await values(map), ["a", "b", "c"]);

package/test/operations/inners.test.js

@@ -1,24 +1,27 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import inners from "../../src/operations/inners.js";
 import plain from "../../src/operations/plain.js";
 
 describe("inners", () => {
   test("returns the interior nodes of a tree", async () => {
-    const obj = new DeepObjectMap({
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
+    const obj = new ObjectMap(
+      {
+        a: 1,
+        b: {
+          c: 2,
+          d: {
+            e: 3,
+          },
+        },
+        f: 4,
+        g: {
+          h: 5,
         },
       },
-      f: 4,
-      g: {
-        h: 5,
-      },
-    });
+      { deep: true }
+    );
     const result = await inners(obj);
     assert.deepEqual(await plain(result), {
       b: {

package/test/operations/map.test.js

@@ -1,6 +1,5 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
 import ObjectMap from "../../src/drivers/ObjectMap.js";
 import map from "../../src/operations/map.js";
 import plain from "../../src/operations/plain.js";
@@ -132,12 +131,15 @@ describe("map", () => {
   });
 
   test("deep maps values", async () => {
-    const tree = new DeepObjectMap({
-      a: "letter a",
-      more: {
-        b: "letter b",
+    const tree = new ObjectMap(
+      {
+        a: "letter a",
+        more: {
+          b: "letter b",
+        },
       },
-    });
+      { deep: true }
+    );
     const uppercaseValues = await map(tree, {
       deep: true,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
@@ -151,12 +153,15 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys", async () => {
-    const tree = new DeepObjectMap({
-      a: "letter a",
-      more: {
-        b: "letter b",
+    const tree = new ObjectMap(
+      {
+        a: "letter a",
+        more: {
+          b: "letter b",
+        },
       },
-    });
+      { deep: true }
+    );
     const underscoreKeys = await map(tree, {
       deep: true,
       key: addUnderscore,
@@ -171,12 +176,15 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys and values", async () => {
-    const tree = new DeepObjectMap({
-      a: "letter a",
-      more: {
-        b: "letter b",
+    const tree = new ObjectMap(
+      {
+        a: "letter a",
+        more: {
+          b: "letter b",
+        },
       },
-    });
+      { deep: true }
+    );
     const underscoreKeysUppercaseValues = await map(tree, {
       deep: true,
       key: addUnderscore,

package/test/operations/mapReduce.test.js

@@ -1,22 +1,24 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import mapReduce from "../../src/operations/mapReduce.js";
+import values from "../../src/operations/values.js";
 
 describe("mapReduce", () => {
   test("can map values and reduce them", async () => {
-    const tree = new DeepObjectMap({
-      a: 1,
-      b: 2,
-      more: {
-        c: 3,
+    const tree = new ObjectMap(
+      {
+        a: 1,
+        b: 2,
+        more: {
+          c: 3,
+        },
+        d: 4,
       },
-      d: 4,
-    });
-    const reduced = await mapReduce(
-      tree,
-      (value) => value,
-      async (values) => String.prototype.concat(...values)
+      { deep: true }
+    );
+    const reduced = await mapReduce(tree, null, async (mapped) =>
+      String.prototype.concat(...(await values(mapped)))
     );
     assert.deepEqual(reduced, "1234");
   });

package/test/operations/mask.test.js

@@ -30,4 +30,16 @@ describe("mask", () => {
       },
     });
   });
+
+  test("can pull from a functional map", async () => {
+    const result = await mask((key) => key.toUpperCase(), {
+      a: true,
+      b: false,
+      c: true,
+    });
+    assert.deepEqual(await plain(result), {
+      a: "A",
+      c: "C",
+    });
+  });
 });

package/test/operations/merge.test.js

@@ -1,6 +1,5 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
 import ObjectMap from "../../src/drivers/ObjectMap.js";
 import keys from "../../src/operations/keys.js";
 import merge from "../../src/operations/merge.js";
@@ -47,11 +46,14 @@ describe("merge", () => {
       new ObjectMap({
         a: 1,
       }),
-      new DeepObjectMap({
-        a: {
-          b: 2,
+      new ObjectMap(
+        {
+          a: {
+            b: 2,
+          },
         },
-      })
+        { deep: true }
+      )
     );
     assert.deepEqual(await keys(fixture), ["a/"]);
     assert.deepEqual(await plain(fixture), {

package/test/operations/paths.test.js

@@ -1,40 +1,33 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
-import ObjectMap from "../../src/drivers/ObjectMap.js";
 import paths from "../../src/operations/paths.js";
 
 describe("paths", () => {
   test("returns an array of paths to the values in the tree", async () => {
-    const tree = new DeepObjectMap({
-      a: 1,
-      b: 2,
-      c: {
-        d: 3,
-        e: 4,
-      },
-    });
+    const tree = new /** @type {any} */ (Map)([
+      ["a", 1],
+      ["b", 2],
+      [
+        "c",
+        new Map([
+          ["d", 3],
+          ["e", 4],
+        ]),
+      ],
+    ]);
     assert.deepEqual(await paths(tree), ["a", "b", "c/d", "c/e"]);
   });
 
-  test("can focus just on keys with trailing slashes", async () => {
-    const tree = new ObjectMap({
-      a: 1,
-      b: 2,
-      // This is a shallow ObjectMap, so `c` won't have a trailing slash
-      c: {
-        d: 3,
-      },
+  test("focuses only on trailing slashes if map supports them", async () => {
+    const tree = new /** @type {any} */ (Map)([
+      ["a", 1],
+      ["b", 2],
+      // No trailing slash; paths will skip this subtree
+      ["c", new Map([["d", 3]])],
       // Explicitly include a trailing slash to signal a subtree
-      "d/": new ObjectMap({
-        e: 4,
-      }),
-    });
-    assert.deepEqual(await paths(tree, { assumeSlashes: true }), [
-      "a",
-      "b",
-      "c",
-      "d/e",
+      ["d/", new Map([["e", 4]])],
     ]);
+    tree.trailingSlashKeys = true;
+    assert.deepEqual(await paths(tree), ["a", "b", "c", "d/e"]);
   });
 });

package/test/operations/regExpKeys.test.js

@@ -1,21 +1,24 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import regExpKeys from "../../src/operations/regExpKeys.js";
 import traverse from "../../src/operations/traverse.js";
 
 describe("regExpKeys", () => {
   test("matches keys using regular expressions", async () => {
     const fixture = await regExpKeys(
-      new DeepObjectMap({
-        "^a$": true,
-        "^b.*": true,
-        c: {
-          d: true,
-          "e*": true,
+      new ObjectMap(
+        {
+          "^a$": true,
+          "^b.*": true,
+          c: {
+            d: true,
+            "e*": true,
+          },
+          f: true,
         },
-        f: true,
-      })
+        { deep: true }
+      )
     );
     assert(await traverse(fixture, "a"));
     assert(!(await traverse(fixture, "alice")));

package/test/operations/set.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import set from "../../src/operations/set.js";
+
+describe("set", () => {
+  test("sets a value", async () => {
+    const map = new Map();
+    await set(map, "key", "value");
+    assert.strictEqual(map.get("key"), "value");
+  });
+});

package/test/operations/traverse.test.js

@@ -39,4 +39,17 @@ describe("traverse", () => {
     });
     assert.equal(await traverse(tree, "a", "b", "c"), "Hello");
   });
+
+  test("unpacks last value if key ends in a slash", async () => {
+    const tree = new ObjectMap({
+      a: {
+        b: Object.assign(new String("packed"), {
+          unpack() {
+            return "unpacked";
+          },
+        }),
+      },
+    });
+    assert.equal(await traverse(tree, "a/", "b/"), "unpacked");
+  });
 });