@weborigami/async-tree 0.5.8 → 0.6.1

package/test/operations/map.test.js

@@ -1,7 +1,8 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import map from "../../src/operations/map.js";
+import plain from "../../src/operations/plain.js";
 import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("map", () => {
@@ -16,7 +17,7 @@ describe("map", () => {
   });
 
   test("maps values", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
       b: "letter b",
       c: undefined, // Won't be mapped
@@ -28,7 +29,7 @@ describe("map", () => {
         return sourceValue.toUpperCase();
       },
     });
-    assert.deepEqual(await Tree.plain(mapped), {
+    assert.deepEqual(await plain(mapped), {
       a: "LETTER A",
       b: "LETTER B",
       c: undefined,
@@ -44,7 +45,7 @@ describe("map", () => {
       assert(sourceKey === "a" || sourceKey === "b");
       return sourceValue.toUpperCase();
     });
-    assert.deepEqual(await Tree.plain(uppercaseValues), {
+    assert.deepEqual(await plain(uppercaseValues), {
       a: "LETTER A",
       b: "LETTER B",
     });
@@ -59,7 +60,7 @@ describe("map", () => {
       key: addUnderscore,
       inverseKey: removeUnderscore,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeys), {
+    assert.deepEqual(await plain(underscoreKeys), {
       _a: "letter a",
       _b: "letter b",
     });
@@ -73,23 +74,23 @@ describe("map", () => {
     const underscoreKeys = await map(tree, {
       key: addUnderscore,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeys), {
+    assert.deepEqual(await plain(underscoreKeys), {
       _a: "letter a",
       _b: "letter b",
     });
   });
 
   test("maps keys and values", async () => {
-    const treelike = new ObjectTree([
+    const maplike = new ObjectMap([
       { name: "Alice", age: 1 },
       { name: "Bob", age: 2 },
       { name: "Carol", age: 3 },
     ]);
-    const result = await map(treelike, {
+    const result = await map(maplike, {
       key: (value, key, tree) => value.name,
       value: (value, key, tree) => value.age,
     });
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await plain(result), {
       Alice: 1,
       Bob: 2,
       Carol: 3,
@@ -108,7 +109,7 @@ describe("map", () => {
       inverseKey: async (resultKey, tree) => resultKey.slice(1),
       value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeys), {
+    assert.deepEqual(await plain(underscoreKeys), {
       _a: "a",
       _more: "more",
     });
@@ -123,24 +124,27 @@ describe("map", () => {
       b: "letter b",
     };
     const mapped = await map(tree, uppercase);
-    assert.deepEqual(await Tree.plain(mapped), {
+    assert.deepEqual(await plain(mapped), {
       _a: "LETTER A",
       _b: "LETTER B",
     });
   });
 
   test("deep maps values", async () => {
-    const tree = new DeepObjectTree({
-      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(),
     });
-    assert.deepEqual(await Tree.plain(uppercaseValues), {
+    assert.deepEqual(await plain(uppercaseValues), {
       a: "LETTER A",
       more: {
         b: "LETTER B",
@@ -149,18 +153,21 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys", async () => {
-    const tree = new DeepObjectTree({
-      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,
       inverseKey: removeUnderscore,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeys), {
+    assert.deepEqual(await plain(underscoreKeys), {
       _a: "letter a",
       more: {
         _b: "letter b",
@@ -169,19 +176,22 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys and values", async () => {
-    const tree = new DeepObjectTree({
-      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,
       inverseKey: removeUnderscore,
       value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    assert.deepEqual(await Tree.plain(underscoreKeysUppercaseValues), {
+    assert.deepEqual(await plain(underscoreKeysUppercaseValues), {
       _a: "LETTER A",
       more: {
         _b: "LETTER B",
@@ -202,7 +212,7 @@ describe("map", () => {
         return key.toUpperCase();
       },
     });
-    assert.deepEqual(await Tree.plain(mapped), {
+    assert.deepEqual(await plain(mapped), {
       A: "letter a",
       B: "letter b",
       C: "letter c",

package/test/operations/mapExtension.test.js

@@ -5,12 +5,12 @@ import plain from "../../src/operations/plain.js";
 
 describe("mapExtension", () => {
   test("can add an extension to a key", async () => {
-    const treelike = {
+    const maplike = {
       "file0.txt": 1,
       file1: 2,
       file2: 3,
     };
-    const fixture = await mapExtension(treelike, "->.data");
+    const fixture = await mapExtension(maplike, "->.data");
     assert.deepEqual(await plain(fixture), {
       "file0.txt.data": 1,
       "file1.data": 2,
@@ -19,12 +19,12 @@ describe("mapExtension", () => {
   });
 
   test("can change a key's extension", async () => {
-    const treelike = {
+    const maplike = {
       "file1.lower": "will be mapped",
       file2: "won't be mapped",
       "file3.foo": "won't be mapped",
     };
-    const fixture = await mapExtension(treelike, {
+    const fixture = await mapExtension(maplike, {
       extension: ".lower->.upper",
       value: (sourceValue) => sourceValue.toUpperCase(),
     });
@@ -34,13 +34,13 @@ describe("mapExtension", () => {
   });
 
   test("can manipulate extensions deeply", async () => {
-    const treelike = {
+    const maplike = {
       "file1.txt": 1,
       more: {
         "file2.txt": 2,
       },
     };
-    const fixture = await mapExtension(treelike, ".txt->", {
+    const fixture = await mapExtension(maplike, ".txt->", {
       deep: true,
     });
     assert.deepEqual(await plain(fixture), {

package/test/operations/mapReduce.test.js

@@ -1,22 +1,24 @@
 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 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 DeepObjectTree({
-      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

@@ -1,7 +1,8 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import keys from "../../src/operations/keys.js";
 import mask from "../../src/operations/mask.js";
+import plain from "../../src/operations/plain.js";
 
 describe("mask", () => {
   test("removes keys and values whose mask values are falsy", async () => {
@@ -21,12 +22,24 @@ describe("mask", () => {
         },
       }
     );
-    assert.deepEqual(await result.keys(), ["a", "c/"]);
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await keys(result), ["a", "c/"]);
+    assert.deepEqual(await plain(result), {
       a: 1,
       c: {
         d: 3,
       },
     });
   });
+
+  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/match.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import match from "../../src/operations/match.js";
+import plain from "../../src/operations/plain.js";
 
 describe("match", () => {
   test("matches keys against a simplified pattern", async () => {
@@ -13,7 +13,7 @@ describe("match", () => {
       "Bob.html",
       "Carol.html",
     ]);
-    assert.deepEqual(await Tree.plain(tree), {
+    assert.deepEqual(await plain(tree), {
       "Alice.html": "Hello, Alice!",
       "Bob.html": "Hello, Bob!",
       "Carol.html": "Hello, Carol!",

package/test/operations/merge.test.js

@@ -1,19 +1,22 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import keys from "../../src/operations/keys.js";
 import merge from "../../src/operations/merge.js";
+import plain from "../../src/operations/plain.js";
+import traverse from "../../src/operations/traverse.js";
 
 describe("merge", () => {
   test("performs a shallow merge", async () => {
-    const fixture = merge(
-      new ObjectTree({
+    const fixture = await merge(
+      new ObjectMap({
         a: 1,
         // Will be obscured by `b` that follows
         b: {
           c: 2,
         },
       }),
-      new ObjectTree({
+      new ObjectMap({
         b: {
           d: 3,
         },
@@ -23,7 +26,7 @@ describe("merge", () => {
       })
     );
 
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       a: 1,
       b: {
         d: 3,
@@ -34,23 +37,26 @@ describe("merge", () => {
     });
 
     // Merge is shallow, and last tree wins, so `b/c` doesn't exist
-    const c = await Tree.traverse(fixture, "b", "c");
+    const c = await traverse(fixture, "b", "c");
     assert.equal(c, undefined);
   });
 
   test("subtree can overwrite a leaf node", async () => {
-    const fixture = merge(
-      new ObjectTree({
+    const fixture = await merge(
+      new ObjectMap({
         a: 1,
       }),
-      new DeepObjectTree({
-        a: {
-          b: 2,
+      new ObjectMap(
+        {
+          a: {
+            b: 2,
+          },
         },
-      })
+        { deep: true }
+      )
     );
-    assert.deepEqual([...(await fixture.keys())], ["a/"]);
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await keys(fixture), ["a/"]);
+    assert.deepEqual(await plain(fixture), {
       a: {
         b: 2,
       },

package/test/operations/paginate.test.js

@@ -1,20 +1,20 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import paginate from "../../src/operations/paginate.js";
+import plain from "../../src/operations/plain.js";
 
 describe("paginate", () => {
   test("divides tree keys into fixed-length chunks", async () => {
-    const treelike = {
+    const maplike = {
       a: 1,
       b: 2,
       c: 3,
       d: 4,
       e: 5,
     };
-    const paginated = await paginate(treelike, 2);
-    const plain = await Tree.plain(paginated);
-    assert.deepEqual(await plain, {
+    const paginated = await paginate(maplike, 2);
+    const result = await plain(paginated);
+    assert.deepEqual(result, {
       1: {
         items: { a: 1, b: 2 },
         nextPage: 2,

package/test/operations/parent.test.js

@@ -1,12 +1,12 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import parent from "../../src/operations/parent.js";
 
 describe("parent", () => {
   test("returns a tree's parent", async () => {
-    const tree = new ObjectTree({
-      sub: new ObjectTree({}),
+    const tree = new ObjectMap({
+      sub: new ObjectMap({}),
     });
     const sub = await tree.get("sub");
     const result = await parent(sub);

package/test/operations/paths.test.js

@@ -1,40 +1,33 @@
 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 paths from "../../src/operations/paths.js";
 
 describe("paths", () => {
   test("returns an array of paths to the values in the tree", async () => {
-    const tree = new DeepObjectTree({
-      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 ObjectTree({
-      a: 1,
-      b: 2,
-      // This is a shallow ObjectTree, 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 ObjectTree({
-        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/plain.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import plain from "../../src/operations/plain.js";
 
 describe("plain", () => {
   test("produces a plain object version of a tree", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: 1,
       // Slashes should be normalized
       "sub1/": {
@@ -28,7 +28,7 @@ describe("plain", () => {
 
   test("produces an array for an array-like tree", async () => {
     const original = ["a", "b", "c"];
-    const tree = new ObjectTree(original);
+    const tree = new ObjectMap(original);
     assert.deepEqual(await plain(tree), original);
   });
 
@@ -39,14 +39,14 @@ describe("plain", () => {
       // missing
       3: "c",
     };
-    const tree = new ObjectTree(original);
+    const tree = new ObjectMap(original);
     assert.deepEqual(await plain(tree), original);
   });
 
-  test("returns empty array or object for ObjectTree as necessary", async () => {
-    const tree = new ObjectTree({});
+  test("returns empty array or object for ObjectMap as necessary", async () => {
+    const tree = new ObjectMap({});
     assert.deepEqual(await plain(tree), {});
-    const arrayTree = new ObjectTree([]);
+    const arrayTree = new ObjectMap([]);
     assert.deepEqual(await plain(arrayTree), []);
   });
 
@@ -60,7 +60,7 @@ describe("plain", () => {
   });
 
   test("coerces TypedArray values to strings", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: new TextEncoder().encode("Hello, world."),
     });
     const result = await plain(tree);

package/test/operations/regExpKeys.test.js

@@ -1,29 +1,33 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, Tree } from "../../src/internal.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 DeepObjectTree({
-        "^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 Tree.traverse(fixture, "a"));
-    assert(!(await Tree.traverse(fixture, "alice")));
-    assert(await Tree.traverse(fixture, "bob"));
-    assert(await Tree.traverse(fixture, "brenda"));
-    assert(await Tree.traverse(fixture, "c/", "d"));
-    assert(await Tree.traverse(fixture, "c/", "eee"));
-    assert(await Tree.traverse(fixture, "f"));
-    assert(await Tree.traverse(fixture, "stef")); // contains "f"
-    assert(!(await Tree.traverse(fixture, "gail")));
+    assert(await traverse(fixture, "a"));
+    assert(!(await traverse(fixture, "alice")));
+    assert(await traverse(fixture, "bob"));
+    assert(await traverse(fixture, "brenda"));
+    assert(await traverse(fixture, "c/", "d"));
+    assert(await traverse(fixture, "c/", "eee"));
+    assert(await traverse(fixture, "f"));
+    assert(await traverse(fixture, "stef")); // contains "f"
+    assert(!(await traverse(fixture, "gail")));
   });
 });

package/test/operations/reverse.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import keys from "../../src/operations/keys.js";
+import plain from "../../src/operations/plain.js";
 import reverse from "../../src/operations/reverse.js";
 
 describe("reverse", () => {
@@ -12,9 +13,9 @@ describe("reverse", () => {
     };
     const reversed = await reverse(tree);
     // @ts-ignore
-    assert.deepEqual(Array.from(await reversed.keys()), ["c", "b", "a"]);
+    assert.deepEqual(await keys(reversed), ["c", "b", "a"]);
     // @ts-ignore
-    assert.deepEqual(await Tree.plain(reversed), {
+    assert.deepEqual(await plain(reversed), {
       c: "C",
       b: "B",
       a: "A",

package/test/operations/scope.test.js

@@ -1,25 +1,26 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import keys from "../../src/operations/keys.js";
 import scope from "../../src/operations/scope.js";
 
 describe("scope", () => {
   test("gets the first defined value from the scope trees", async () => {
-    const outer = new ObjectTree({
+    const outer = new ObjectMap({
       a: 1,
       b: 2,
     });
-    const inner = new ObjectTree({
+    const inner = new ObjectMap({
       a: 3,
     });
     inner.parent = outer;
     const innerScope = await scope(inner);
-    assert.deepEqual([...(await innerScope.keys())], ["a", "b"]);
+    assert.deepEqual(await keys(innerScope), ["a", "b"]);
     // Inner tree has precedence
     assert.equal(await innerScope.get("a"), 3);
     // If tree doesn't have value, finds value from parent
     assert.equal(await innerScope.get("b"), 2);
     assert.equal(await innerScope.get("c"), undefined);
-    assert.deepEqual(innerScope.trees, [inner, outer]);
+    assert.deepEqual(/** @type {any} */ (innerScope).trees, [inner, outer]);
   });
 });

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");
+  });
+});