@weborigami/async-tree 0.5.8 → 0.6.1

package/test/operations/deepMerge.test.js

@@ -1,30 +1,37 @@
 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 deepMerge from "../../src/operations/deepMerge.js";
+import plain from "../../src/operations/plain.js";
 
 describe("mergeDeep", () => {
   test("can merge deep", async () => {
-    const fixture = deepMerge(
-      new DeepObjectTree({
-        a: {
-          b: 0, // Will be obscured by `b` below
-          c: {
-            d: 2,
+    const fixture = await deepMerge(
+      new ObjectMap(
+        {
+          a: {
+            b: 0, // Will be obscured by `b` below
+            c: {
+              d: 2,
+            },
           },
         },
-      }),
-      new DeepObjectTree({
-        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 Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       a: {
         b: 1,
         c: {

package/test/operations/deepReverse.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import deepReverse from "../../src/operations/deepReverse.js";
+import plain from "../../src/operations/plain.js";
 
 describe("deepReverse", () => {
   test("reverses keys at all levels of a tree", async () => {
@@ -13,7 +13,7 @@ describe("deepReverse", () => {
       },
     };
     const reversed = await deepReverse(tree);
-    assert.deepEqual(await Tree.plain(reversed), {
+    assert.deepEqual(await plain(reversed), {
       b: {
         d: 3,
         c: 2,

package/test/operations/deepTake.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import deepTake from "../../src/operations/deepTake.js";
+import plain from "../../src/operations/plain.js";
 
 describe("deepTake", () => {
   test("traverses deeply and returns a limited number of items", async () => {
@@ -17,6 +17,6 @@ describe("deepTake", () => {
       g: 5,
     };
     const result = await deepTake(tree, 4);
-    assert.deepEqual(await Tree.plain(result), [1, 2, 3, 4]);
+    assert.deepEqual(await plain(result), [1, 2, 3, 4]);
   });
 });

package/test/operations/deepText.test.js

@@ -1,12 +1,12 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import FunctionTree from "../../src/drivers/FunctionTree.js";
-import { Tree } from "../../src/internal.js";
+import FunctionMap from "../../src/drivers/FunctionMap.js";
 import deepText from "../../src/operations/deepText.js";
+import from from "../../src/operations/from.js";
 
 describe("deepText", () => {
   test("concatenates deep tree values", async () => {
-    const tree = Tree.from({
+    const tree = from({
       a: "A",
       b: "B",
       c: "C",
@@ -21,7 +21,7 @@ describe("deepText", () => {
 
   test("concatenates deep tree-like values", async () => {
     const letters = ["a", "b", "c"];
-    const specimens = new FunctionTree(
+    const specimens = new FunctionMap(
       (letter) => ({
         lowercase: letter,
         uppercase: letter.toUpperCase(),

package/test/operations/deepValuesIterator.test.js

@@ -1,11 +1,11 @@
 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 deepValuesIterator from "../../src/operations/deepValuesIterator.js";
 
 describe("deepValuesIterator", () => {
   test("returns an iterator of a tree's deep values", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: 1,
       b: 2,
       more: {

package/test/operations/delete.test.js

@@ -1,12 +1,12 @@
 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 { default as del } from "../../src/operations/delete.js";
 import plain from "../../src/operations/plain.js";
 
 describe("delete", () => {
   test("removes a value", async () => {
-    const fixture = new ObjectTree({
+    const fixture = new ObjectMap({
       "Alice.md": "Hello, **Alice**.",
       "Bob.md": "Hello, **Bob**.",
       "Carol.md": "Hello, **Carol**.",

package/test/operations/extensionKeyFunctions.test.js

@@ -1,8 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree, Tree } from "../../src/internal.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import extensionKeyFunctions from "../../src/operations/extensionKeyFunctions.js";
 import map from "../../src/operations/map.js";
+import plain from "../../src/operations/plain.js";
 
 describe("keyMapsForExtensions", () => {
   test("returns key functions that pass a matching key through", async () => {
@@ -34,7 +35,7 @@ describe("keyMapsForExtensions", () => {
   });
 
   test("works with map to handle keys that end in a given resultExtension", async () => {
-    const files = new ObjectTree({
+    const files = new ObjectMap({
       "file1.txt": "will be mapped",
       file2: "won't be mapped",
       "file3.foo": "won't be mapped",
@@ -45,13 +46,13 @@ describe("keyMapsForExtensions", () => {
       key,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       "file1.txt": "WILL BE MAPPED",
     });
   });
 
   test("works with map to change a key's resultExtension", async () => {
-    const files = new ObjectTree({
+    const files = new ObjectMap({
       "file1.txt": "will be mapped",
       file2: "won't be mapped",
       "file3.foo": "won't be mapped",
@@ -62,7 +63,7 @@ describe("keyMapsForExtensions", () => {
       key,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       "file1.upper": "WILL BE MAPPED",
     });
   });

package/test/operations/filter.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import filter from "../../src/operations/filter.js";
+import plain from "../../src/operations/plain.js";
 
 describe("filter", () => {
   test("returns values that pass a filter function", async () => {
@@ -14,7 +14,7 @@ describe("filter", () => {
       },
       (value) => value % 2 === 1 // odd
     );
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await plain(result), {
       a: 1,
       c: 3,
     });
@@ -35,7 +35,7 @@ describe("filter", () => {
         test: (value) => value % 2 === 1, // odd
       }
     );
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await plain(result), {
       a: 1,
       c: {
         d: 3,

package/test/operations/from.test.js

@@ -1,42 +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 ObjectMap from "../../src/drivers/ObjectMap.js";
+import SetMap from "../../src/drivers/SetMap.js";
 import from from "../../src/operations/from.js";
-import plain from "../../src/operations/plain.js";
+import values from "../../src/operations/values.js";
 import * as symbols from "../../src/symbols.js";
 
 describe("from", () => {
-  test("returns an async tree as is", async () => {
-    const tree1 = new ObjectTree({
-      a: "Hello, a.",
-    });
+  test("returns a Map as is", async () => {
+    const tree1 = new Map([
+      ["a", 1],
+      ["b", 2],
+    ]);
     const tree2 = from(tree1);
     assert.equal(tree2, tree1);
   });
 
-  test("uses an object's unpack() method if defined", async () => {
-    const obj = new String();
-    /** @type {any} */ (obj).unpack = () => ({
-      a: "Hello, a.",
-    });
-    const tree = from(obj);
-    assert.deepEqual(await plain(tree), {
-      a: "Hello, a.",
-    });
-  });
-
-  test("returns a deep object tree if deep option is true", async () => {
+  test("returns a deep object map if deep option is true", async () => {
     const obj = {
       sub: {
         a: 1,
       },
     };
     const tree = from(obj, { deep: true });
-    assert(tree instanceof DeepObjectTree);
+    assert(tree instanceof ObjectMap);
+    assert(tree.deep);
   });
 
-  test("returns a deep object tree if object has [deep] symbol set", async () => {
+  test("returns a deep object map if object has [deep] symbol set", async () => {
     const obj = {
       sub: {
         a: 1,
@@ -44,18 +35,21 @@ describe("from", () => {
     };
     Object.defineProperty(obj, symbols.deep, { value: true });
     const tree = from(obj);
-    assert(tree instanceof DeepObjectTree);
+    assert(tree instanceof ObjectMap);
+    assert(tree.deep);
   });
 
-  test("creates a deferred tree if unpack() returns a promise", async () => {
-    const obj = new String();
-    /** @type {any} */ (obj).unpack = async () => ({
-      a: "Hello, a.",
-    });
-    const tree = from(obj);
-    assert.deepEqual(await plain(tree), {
-      a: "Hello, a.",
-    });
+  test("returns a SetMap for Set objects", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const map = from(set);
+    assert(map instanceof SetMap);
+    assert.deepEqual(await values(map), ["a", "b", "c"]);
+  });
+
+  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"]);
   });
 
   test("autoboxes primitive values", async () => {

package/test/operations/globKeys.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import globKeys from "../../src/operations/globKeys.js";
+import traverse from "../../src/operations/traverse.js";
 
 describe("globKeys", () => {
   test("matches globs", async () => {
@@ -26,8 +26,8 @@ describe("globKeys", () => {
         "*": "default",
       },
     });
-    assert.equal(await Tree.traverse(globTree, "sub/", "file"), "default");
-    assert.equal(await Tree.traverse(globTree, "sub/", "foo"), "bar");
+    assert.equal(await traverse(globTree, "sub/", "file"), "default");
+    assert.equal(await traverse(globTree, "sub/", "foo"), "bar");
   });
 
   test("supports deep matches with globstar", async () => {
@@ -43,11 +43,11 @@ describe("globKeys", () => {
         "*.html": true,
       },
     });
-    assert.equal(await Tree.traverse(globTree, "a/", "b/", "foo.txt"), true);
-    assert.equal(await Tree.traverse(globTree, "c/", "foo"), false);
-    assert.equal(await Tree.traverse(globTree, "sub/", "file.md"), true);
-    assert.equal(await Tree.traverse(globTree, "sub/", "file.txt"), true);
-    assert.equal(await Tree.traverse(globTree, "sub/", "file.html"), true);
-    assert.equal(await Tree.traverse(globTree, "sub/", "file"), false);
+    assert.equal(await traverse(globTree, "a/", "b/", "foo.txt"), true);
+    assert.equal(await traverse(globTree, "c/", "foo"), false);
+    assert.equal(await traverse(globTree, "sub/", "file.md"), true);
+    assert.equal(await traverse(globTree, "sub/", "file.txt"), true);
+    assert.equal(await traverse(globTree, "sub/", "file.html"), true);
+    assert.equal(await traverse(globTree, "sub/", "file"), false);
   });
 });

package/test/operations/groupBy.test.js

@@ -1,7 +1,8 @@
 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 groupBy from "../../src/operations/groupBy.js";
+import plain from "../../src/operations/plain.js";
 
 describe("groupBy transform", () => {
   test("groups an array using a group key function", async () => {
@@ -11,9 +12,9 @@ describe("groupBy transform", () => {
       { name: "Alegreya", tags: ["Serif"] },
       { name: "Work Sans", tags: ["Grotesque", "Sans Serif"] },
     ];
-    const tree = Tree.from(fonts);
+    const tree = from(fonts);
     const grouped = await groupBy(tree, (value, key, tree) => value.tags);
-    assert.deepEqual(await Tree.plain(grouped), {
+    assert.deepEqual(await plain(grouped), {
       Geometric: [{ name: "Albert Sans", tags: ["Geometric", "Sans Serif"] }],
       Grotesque: [{ name: "Work Sans", tags: ["Grotesque", "Sans Serif"] }],
       "Sans Serif": [
@@ -32,9 +33,9 @@ describe("groupBy transform", () => {
       Alegreya: { tags: ["Serif"] },
       "Work Sans": { tags: ["Grotesque", "Sans Serif"] },
     };
-    const tree = Tree.from(fonts);
+    const tree = from(fonts);
     const grouped = await groupBy(tree, (value, key, tree) => value.tags);
-    assert.deepEqual(await Tree.plain(grouped), {
+    assert.deepEqual(await plain(grouped), {
       Geometric: {
         "Albert Sans": { tags: ["Geometric", "Sans Serif"] },
       },

package/test/operations/inners.test.js

@@ -1,26 +1,29 @@
 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 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 DeepObjectTree({
-      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);
-    const plain = await Tree.plain(result);
-    assert.deepEqual(plain, {
+    assert.deepEqual(await plain(result), {
       b: {
         d: {},
       },

package/test/operations/invokeFunctions.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
 import invokeFunctions from "../../src/operations/invokeFunctions.js";
+import plain from "../../src/operations/plain.js";
 
 describe("invokeFunctions", () => {
   test("invokes function values, leaves other values as is", async () => {
@@ -9,7 +9,7 @@ describe("invokeFunctions", () => {
       a: 1,
       b: () => 2,
     });
-    assert.deepEqual(await Tree.plain(fixture), {
+    assert.deepEqual(await plain(fixture), {
       a: 1,
       b: 2,
     });

package/test/operations/isMap.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import AsyncMap from "../../src/drivers/AsyncMap.js";
+import isMap from "../../src/operations/isMap.js";
+
+describe("isMap", () => {
+  test("returns true if the object is a Map or AsyncMap", () => {
+    assert(!isMap(null));
+    assert(!isMap(1));
+    assert(!isMap({}));
+    assert(!isMap([]));
+    assert(isMap(new Map()));
+    assert(isMap(new AsyncMap()));
+  });
+});

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