@weborigami/async-tree 0.5.7 → 0.6.0

package/test/operations/isMaplike.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import isMaplike from "../../src/operations/isMaplike.js";
+
+describe("isMaplike", () => {
+  test("returns true if the argument can be cast to an async map", () => {
+    assert(!isMaplike(null));
+    assert(!isMaplike(1));
+    assert(isMaplike({}));
+    assert(isMaplike([]));
+    assert(isMaplike(new Map()));
+    assert(isMaplike(new Map().keys())); // Iterator
+    assert(isMaplike(new Set()));
+  });
+});

package/test/operations/json.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import from from "../../src/operations/from.js";
 import json from "../../src/operations/json.js";
 
 describe("json", () => {
   test("renders a tree in JSON format", async () => {
-    const tree = Tree.from({ person1: "Alice", person2: "Bob" });
+    const tree = from({ person1: "Alice", person2: "Bob" });
     const result = await json(tree);
     assert.equal(
       result,

package/test/operations/keys.test.js

@@ -1,15 +1,28 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import AsyncMap from "../../src/drivers/AsyncMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import keys from "../../src/operations/keys.js";
 
 describe("keys", () => {
-  test("returns the keys of a tree as an array", async () => {
-    const obj = {
+  test("handles regular iterable", async () => {
+    const obj = new ObjectMap({
       a: 1,
       b: 2,
       c: 3,
-    };
+    });
     const result = await keys(obj);
     assert.deepEqual(result, ["a", "b", "c"]);
   });
+
+  test("handles async iterable", async () => {
+    const map = new AsyncMap();
+    map.keys = async function* () {
+      yield "x";
+      yield "y";
+      yield "z";
+    };
+    const result = await keys(map);
+    assert.deepEqual(result, ["x", "y", "z"]);
+  });
 });

package/test/operations/map.test.js

@@ -1,7 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+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";
 import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("map", () => {
@@ -16,7 +18,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 +30,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 +46,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 +61,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 +75,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 +110,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,14 +125,14 @@ 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({
+    const tree = new DeepObjectMap({
       a: "letter a",
       more: {
         b: "letter b",
@@ -140,7 +142,7 @@ describe("map", () => {
       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,7 +151,7 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: "letter a",
       more: {
         b: "letter b",
@@ -160,7 +162,7 @@ describe("map", () => {
       key: addUnderscore,
       inverseKey: removeUnderscore,
     });
-    assert.deepEqual(await Tree.plain(underscoreKeys), {
+    assert.deepEqual(await plain(underscoreKeys), {
       _a: "letter a",
       more: {
         _b: "letter b",
@@ -169,7 +171,7 @@ describe("map", () => {
   });
 
   test("deep maps leaf keys and values", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: "letter a",
       more: {
         b: "letter b",
@@ -181,7 +183,7 @@ describe("map", () => {
       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 +204,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,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 mapReduce from "../../src/operations/mapReduce.js";
 
 describe("mapReduce", () => {
   test("can map values and reduce them", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: 1,
       b: 2,
       more: {

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,8 +22,8 @@ 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,

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,23 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+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";
+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 +27,7 @@ describe("merge", () => {
       })
     );
 
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       a: 1,
       b: {
         d: 3,
@@ -34,23 +38,23 @@ 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({
+      new DeepObjectMap({
         a: {
           b: 2,
         },
       })
     );
-    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,12 +1,12 @@
 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 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 DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: 1,
       b: 2,
       c: {
@@ -18,15 +18,15 @@ describe("paths", () => {
   });
 
   test("can focus just on keys with trailing slashes", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: 1,
       b: 2,
-      // This is a shallow ObjectTree, so `c` won't have a trailing slash
+      // This is a shallow ObjectMap, so `c` won't have a trailing slash
       c: {
         d: 3,
       },
       // Explicitly include a trailing slash to signal a subtree
-      "d/": new ObjectTree({
+      "d/": new ObjectMap({
         e: 4,
       }),
     });

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,12 +1,13 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, Tree } from "../../src/internal.js";
+import DeepObjectMap from "../../src/drivers/DeepObjectMap.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({
+      new DeepObjectMap({
         "^a$": true,
         "^b.*": true,
         c: {
@@ -16,14 +17,14 @@ describe("regExpKeys", () => {
         f: 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/shuffle.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import keys from "../../src/operations/keys.js";
 import shuffle from "../../src/operations/shuffle.js";
 
 describe("shuffle", () => {
@@ -12,7 +13,7 @@ describe("shuffle", () => {
       e: 5,
     };
     const result = await shuffle(obj);
-    const keys = Array.from(await result.keys());
-    assert.deepEqual(keys.sort(), Object.keys(obj).sort());
+    const treeKeys = await keys(result);
+    assert.deepEqual(treeKeys.sort(), Object.keys(obj).sort());
   });
 });