@weborigami/async-tree 0.5.3 → 0.5.5

package/test/operations/map.test.js

@@ -1,20 +1,17 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import FunctionTree from "../../src/drivers/FunctionTree.js";
 import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import map from "../../src/operations/map.js";
 import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("map", () => {
-  test("returns identity graph if no key or value function is supplied", async () => {
+  test("throws if no key or value function is supplied", async () => {
     const tree = {
       a: "letter a",
       b: "letter b",
     };
-    const mapped = map(tree, {});
-    assert.deepEqual(await Tree.plain(mapped), {
-      a: "letter a",
-      b: "letter b",
+    assert.rejects(async () => {
+      await map(tree, {});
     });
   });
 
@@ -24,7 +21,7 @@ describe("map", () => {
       b: "letter b",
       c: undefined, // Won't be mapped
     });
-    const mapped = map(tree, {
+    const mapped = await map(tree, {
       value: (sourceValue, sourceKey, innerTree) => {
         assert(sourceKey === "a" || sourceKey === "b");
         assert.equal(innerTree, tree);
@@ -43,7 +40,7 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    const uppercaseValues = map(tree, (sourceValue, sourceKey, tree) => {
+    const uppercaseValues = await map(tree, (sourceValue, sourceKey, tree) => {
       assert(sourceKey === "a" || sourceKey === "b");
       return sourceValue.toUpperCase();
     });
@@ -58,7 +55,7 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    const underscoreKeys = map(tree, {
+    const underscoreKeys = await map(tree, {
       key: addUnderscore,
       inverseKey: removeUnderscore,
     });
@@ -73,7 +70,7 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    const underscoreKeys = map(tree, {
+    const underscoreKeys = await map(tree, {
       key: addUnderscore,
     });
     assert.deepEqual(await Tree.plain(underscoreKeys), {
@@ -83,18 +80,19 @@ describe("map", () => {
   });
 
   test("maps keys and values", async () => {
-    const tree = {
-      a: "letter a",
-      b: "letter b",
-    };
-    const underscoreKeysUppercaseValues = map(tree, {
-      key: addUnderscore,
-      inverseKey: removeUnderscore,
-      value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+    const treelike = new ObjectTree([
+      { name: "Alice", age: 1 },
+      { name: "Bob", age: 2 },
+      { name: "Carol", age: 3 },
+    ]);
+    const result = await map(treelike, {
+      key: (value, key, tree) => value.name,
+      value: (value, key, tree) => value.age,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeysUppercaseValues), {
-      _a: "LETTER A",
-      _b: "LETTER B",
+    assert.deepEqual(await Tree.plain(result), {
+      Alice: 1,
+      Bob: 2,
+      Carol: 3,
     });
   });
 
@@ -105,8 +103,8 @@ describe("map", () => {
         b: "letter b",
       },
     };
-    const underscoreKeys = map(tree, {
-      key: async (sourceKey, tree) => `_${sourceKey}`,
+    const underscoreKeys = await map(tree, {
+      key: async (value, sourceKey, tree) => `_${sourceKey}`,
       inverseKey: async (resultKey, tree) => resultKey.slice(1),
       value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
@@ -124,7 +122,7 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    const mapped = map(tree, uppercase);
+    const mapped = await map(tree, uppercase);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
       _b: "LETTER B",
@@ -138,7 +136,7 @@ describe("map", () => {
         b: "letter b",
       },
     });
-    const uppercaseValues = map(tree, {
+    const uppercaseValues = await map(tree, {
       deep: true,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
@@ -157,7 +155,7 @@ describe("map", () => {
         b: "letter b",
       },
     });
-    const underscoreKeys = map(tree, {
+    const underscoreKeys = await map(tree, {
       deep: true,
       key: addUnderscore,
       inverseKey: removeUnderscore,
@@ -177,7 +175,7 @@ describe("map", () => {
         b: "letter b",
       },
     });
-    const underscoreKeysUppercaseValues = map(tree, {
+    const underscoreKeysUppercaseValues = await map(tree, {
       deep: true,
       key: addUnderscore,
       inverseKey: removeUnderscore,
@@ -191,6 +189,42 @@ describe("map", () => {
     });
   });
 
+  test("keyNeedsSourceValue can be set to false in cases where the value isn't necessary", async () => {
+    const tree = {
+      a: "letter a",
+      b: "letter b",
+      c: "letter c",
+    };
+    const mapped = await map(tree, {
+      keyNeedsSourceValue: false,
+      key: (value, key) => {
+        assert.equal(value, null);
+        return key.toUpperCase();
+      },
+    });
+    assert.deepEqual(await Tree.plain(mapped), {
+      A: "letter a",
+      B: "letter b",
+      C: "letter c",
+    });
+  });
+
+  test("can add an extension to a key", async () => {
+    const treelike = {
+      "file0.txt": 1,
+      file1: 2,
+      file2: 3,
+    };
+    const fixture = await map(treelike, {
+      extension: "->.data",
+    });
+    assert.deepEqual(await Tree.plain(fixture), {
+      "file0.txt.data": 1,
+      "file1.data": 2,
+      "file2.data": 3,
+    });
+  });
+
   test("can change a key's extension", async () => {
     const treelike = {
       "file1.lower": "will be mapped",
@@ -224,26 +258,9 @@ describe("map", () => {
       },
     });
   });
-
-  test("needsSourceValue can be set to false in cases where the value isn't necessary", async () => {
-    let flag = false;
-    const tree = new FunctionTree(() => {
-      flag = true;
-    }, ["a", "b", "c"]);
-    const mapped = map(tree, {
-      needsSourceValue: false,
-      value: () => "X",
-    });
-    assert.deepEqual(await Tree.plain(mapped), {
-      a: "X",
-      b: "X",
-      c: "X",
-    });
-    assert(!flag);
-  });
 });
 
-function addUnderscore(key) {
+function addUnderscore(value, key) {
   return `_${key}`;
 }
 

package/test/operations/mapReduce.test.js

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

package/test/operations/mask.test.js

@@ -5,7 +5,7 @@ import mask from "../../src/operations/mask.js";
 
 describe("mask", () => {
   test("removes keys and values whose mask values are falsy", async () => {
-    const result = mask(
+    const result = await mask(
       {
         a: 1,
         b: 2,

package/test/operations/match.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import match from "../../src/operations/match.js";
+
+describe("match", () => {
+  test("matches keys against a simplified pattern", async () => {
+    function fn(matches) {
+      return `Hello, ${matches.name}!`;
+    }
+    const tree = match("[name].html", fn, [
+      "Alice.html",
+      "Bob.html",
+      "Carol.html",
+    ]);
+    assert.deepEqual(await Tree.plain(tree), {
+      "Alice.html": "Hello, Alice!",
+      "Bob.html": "Hello, Bob!",
+      "Carol.html": "Hello, Carol!",
+    });
+    const value = await tree.get("David.html");
+    assert.equal(value, "Hello, David!");
+  });
+
+  test("matches keys against a regular expression", async () => {
+    function fn(matches) {
+      return `Hello, ${matches.name}!`;
+    }
+    const tree = match(/^(?<name>.+)\.html$/, fn);
+    const value = await tree.get("Alice.html");
+    assert.equal(value, "Hello, Alice!");
+  });
+});

package/test/operations/merge.test.js

@@ -2,26 +2,25 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import merge from "../../src/operations/merge.js";
-import * as symbols from "../../src/symbols.js";
 
 describe("merge", () => {
   test("performs a shallow merge", async () => {
     const fixture = merge(
-      {
+      new ObjectTree({
         a: 1,
         // Will be obscured by `b` that follows
         b: {
           c: 2,
         },
-      },
-      {
+      }),
+      new ObjectTree({
         b: {
           d: 3,
         },
         e: {
           f: 4,
         },
-      }
+      })
     );
 
     assert.deepEqual(await Tree.plain(fixture), {
@@ -37,10 +36,6 @@ describe("merge", () => {
     // Merge is shallow, and last tree wins, so `b/c` doesn't exist
     const c = await Tree.traverse(fixture, "b", "c");
     assert.equal(c, undefined);
-
-    // Parent of a subvalue is the merged tree
-    const b = await fixture.get("b");
-    assert.equal(b[symbols.parent], fixture);
   });
 
   test("subtree can overwrite a leaf node", async () => {
@@ -61,4 +56,23 @@ describe("merge", () => {
       },
     });
   });
+
+  test("if all arguments are plain objects, result is a plain object", async () => {
+    const result = await merge(
+      {
+        a: 1,
+        b: 2,
+      },
+      {
+        c: 3,
+        d: 4,
+      }
+    );
+    assert.deepEqual(result, {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+    });
+  });
 });

package/test/operations/paginate.test.js

@@ -13,7 +13,8 @@ describe("paginate", () => {
       e: 5,
     };
     const paginated = await paginate.call(null, treelike, 2);
-    assert.deepEqual(await Tree.plain(paginated), {
+    const plain = await Tree.plain(paginated);
+    assert.deepEqual(await plain, {
       1: {
         items: { a: 1, b: 2 },
         nextPage: 2,

package/test/operations/parent.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { ObjectTree } from "../../src/internal.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 sub = await tree.get("sub");
+    const result = await parent(sub);
+    assert.equal(result, tree);
+  });
+});

package/test/operations/paths.test.js

@@ -0,0 +1,40 @@
+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,
+      },
+    });
+    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,
+      },
+      // 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",
+    ]);
+  });
+});

package/test/operations/plain.test.js

@@ -0,0 +1,69 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import plain from "../../src/operations/plain.js";
+
+describe("plain", () => {
+  test("produces a plain object version of a tree", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      // Slashes should be normalized
+      "sub1/": {
+        b: 2,
+      },
+      sub2: {
+        c: 3,
+      },
+    });
+    assert.deepEqual(await plain(tree), {
+      a: 1,
+      sub1: {
+        b: 2,
+      },
+      sub2: {
+        c: 3,
+      },
+    });
+  });
+
+  test("produces an array for an array-like tree", async () => {
+    const original = ["a", "b", "c"];
+    const tree = new ObjectTree(original);
+    assert.deepEqual(await plain(tree), original);
+  });
+
+  test("leaves an array-like tree as an object if keys aren't consecutive", async () => {
+    const original = {
+      0: "a",
+      1: "b",
+      // missing
+      3: "c",
+    };
+    const tree = new ObjectTree(original);
+    assert.deepEqual(await plain(tree), original);
+  });
+
+  test("returns empty array or object for ObjectTree as necessary", async () => {
+    const tree = new ObjectTree({});
+    assert.deepEqual(await plain(tree), {});
+    const arrayTree = new ObjectTree([]);
+    assert.deepEqual(await plain(arrayTree), []);
+  });
+
+  test("awaits async properties", async () => {
+    const object = {
+      get name() {
+        return Promise.resolve("Alice");
+      },
+    };
+    assert.deepEqual(await plain(object), { name: "Alice" });
+  });
+
+  test("coerces TypedArray values to strings", async () => {
+    const tree = new ObjectTree({
+      a: new TextEncoder().encode("Hello, world."),
+    });
+    const result = await plain(tree);
+    assert.equal(result.a, "Hello, world.");
+  });
+});

package/test/operations/reverse.test.js

@@ -10,7 +10,7 @@ describe("reverse", () => {
       b: "B",
       c: "C",
     };
-    const reversed = reverse.call(null, tree);
+    const reversed = await reverse.call(null, tree);
     // @ts-ignore
     assert.deepEqual(Array.from(await reversed.keys()), ["c", "b", "a"]);
     // @ts-ignore

package/test/operations/scope.test.js

@@ -13,7 +13,7 @@ describe("scope", () => {
       a: 3,
     });
     inner.parent = outer;
-    const innerScope = scope(inner);
+    const innerScope = await scope(inner);
     assert.deepEqual([...(await innerScope.keys())], ["a", "b"]);
     // Inner tree has precedence
     assert.equal(await innerScope.get("a"), 3);

package/test/operations/setDeep.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+import setDeep from "../../src/operations/setDeep.js";
+
+describe("tree/setDeep", () => {
+  test("can apply updates with a single argument to set", async () => {
+    const tree = new DeepObjectTree({
+      a: 1,
+      b: 2,
+      more: {
+        d: 3,
+      },
+    });
+
+    // Apply changes.
+    await setDeep.call(
+      null,
+      tree,
+      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,
+        },
+      })
+    );
+
+    assert.deepEqual(await Tree.plain(tree), {
+      a: 4,
+      c: 5,
+      more: {
+        d: 3,
+        e: 6,
+      },
+      extra: {
+        f: 7,
+      },
+    });
+  });
+
+  test("can apply updates to an array", async () => {
+    const tree = new ObjectTree(["a", "b", "c"]);
+    await setDeep.call(null, tree, ["d", "e"]);
+    assert.deepEqual(await Tree.plain(tree), ["d", "e", "c"]);
+  });
+});

package/test/operations/shuffle.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import shuffle from "../../src/operations/shuffle.js";
+
+describe("shuffle", () => {
+  test("shuffles the keys of a tree", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+      e: 5,
+    };
+    const result = await shuffle(obj);
+    const keys = Array.from(await result.keys());
+    assert.deepEqual(keys.sort(), Object.keys(obj).sort());
+  });
+});

package/test/operations/sort.test.js

@@ -10,7 +10,7 @@ describe("sort", () => {
       file1: null,
       file9: null,
     });
-    const sorted = sort(tree);
+    const sorted = await sort(tree);
     assert.deepEqual(Array.from(await sorted.keys()), [
       "file1",
       "file10",
@@ -26,7 +26,7 @@ describe("sort", () => {
     });
     // Reverse order
     const compare = (a, b) => (a > b ? -1 : a < b ? 1 : 0);
-    const sorted = sort(tree, { compare });
+    const sorted = await sort(tree, { compare });
     assert.deepEqual(Array.from(await sorted.keys()), ["c", "b", "a"]);
   });
 
@@ -37,7 +37,7 @@ describe("sort", () => {
       Carol: { age: 42 },
     };
     const sorted = await sort(tree, {
-      sortKey: async (key, tree) => Tree.traverse(tree, key, "age"),
+      sortKey: async (value, key, tree) => value.age,
     });
     assert.deepEqual(Array.from(await sorted.keys()), [
       "Bob",

package/test/operations/toFunction.test.js

@@ -0,0 +1,16 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import toFunction from "../../src/operations/toFunction.js";
+
+describe("toFunction", () => {
+  test("returns a function that invokes a tree's get() method", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      b: 2,
+    });
+    const fn = await toFunction(tree);
+    assert.equal(await fn("a"), 1);
+    assert.equal(await fn("b"), 2);
+  });
+});

package/test/operations/traverse.test.js

@@ -0,0 +1,43 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import MapTree from "../../src/drivers/MapTree.js";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import traverse from "../../src/operations/traverse.js";
+
+describe("traverse", () => {
+  test("traverses a path of keys", async () => {
+    const tree = new ObjectTree({
+      a1: 1,
+      a2: {
+        b1: 2,
+        b2: {
+          c1: 3,
+          c2: 4,
+        },
+      },
+    });
+    assert.equal(await traverse(tree), tree);
+    assert.equal(await traverse(tree, "a1"), 1);
+    assert.equal(await traverse(tree, "a2", "b2", "c2"), 4);
+    assert.equal(await traverse(tree, "a2", "doesntexist", "c2"), undefined);
+  });
+
+  test("traverses a function with fixed number of arguments", async () => {
+    const tree = (a, b) => ({
+      c: "Result",
+    });
+    assert.equal(await traverse(tree, "a", "b", "c"), "Result");
+  });
+
+  test("traverses from one tree into another", async () => {
+    const tree = new ObjectTree({
+      a: {
+        b: new MapTree([
+          ["c", "Hello"],
+          ["d", "Goodbye"],
+        ]),
+      },
+    });
+    assert.equal(await traverse(tree, "a", "b", "c"), "Hello");
+  });
+});

package/test/operations/traversePath.test.js

@@ -0,0 +1,16 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import traversePath from "../../src/operations/traversePath.js";
+
+describe("traversePath", () => {
+  test("traversePath() traverses a slash-separated path", async () => {
+    const tree = {
+      a: {
+        b: {
+          c: "Hello",
+        },
+      },
+    };
+    assert.equal(await traversePath(tree, "a/b/c"), "Hello");
+  });
+});