@weborigami/async-tree 0.5.7 → 0.6.0

package/test/operations/assign.test.js

@@ -1,53 +1,48 @@
 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 SyncMap from "../../src/drivers/SyncMap.js";
 import assign from "../../src/operations/assign.js";
 import plain from "../../src/operations/plain.js";
+import { deepEntries } from "../../src/Tree.js";
+import SampleAsyncMap from "../SampleAsyncMap.js";
 
 describe("assign", () => {
-  test("assign applies one tree to another", async () => {
-    const target = new DeepObjectTree({
-      a: 1,
-      b: 2,
-      more: {
-        d: 3,
-      },
-    });
+  test("assign can apply updates from an async tree to a sync tree", async () => {
+    const target = new SyncMap([
+      ["a", 1],
+      ["b", 2],
+      ["more", new SyncMap([["d", 3]])],
+    ]);
 
-    const source = 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,
-      },
-    });
+    const source = new SampleAsyncMap([
+      ["a", 4], // Overwrite existing value
+      ["c", 5], // Add
+      ["more", [["e", 6]]], // Should leave existing `more` keys alone.
+      ["extra", [["f", 7]]], // Add new subtree
+    ]);
 
     // Apply changes.
     const result = await assign(target, source);
 
     assert.equal(result, target);
-    assert.deepEqual(await plain(target), {
-      a: 4,
-      c: 5,
-      more: {
-        d: 3,
-        e: 6,
-      },
-      extra: {
-        f: 7,
-      },
-    });
+    assert.deepEqual(await deepEntries(target), [
+      ["a", 4],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["d", 3],
+          ["e", 6],
+        ],
+      ],
+      ["c", 5],
+      ["extra", [["f", 7]]],
+    ]);
   });
 
   test("assign() can apply updates to an array", async () => {
-    const target = new ObjectTree(["a", "b", "c"]);
+    const target = new ObjectMap(["a", "b", "c"]);
     await assign(target, ["d", "e"]);
     assert.deepEqual(await plain(target), ["d", "e", "c"]);
   });

package/test/operations/cache.test.js

@@ -1,13 +1,15 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import SyncMap from "../../src/drivers/SyncMap.js";
 import cache from "../../src/operations/cache.js";
+import keys from "../../src/operations/keys.js";
 
 describe("cache", () => {
   test("caches reads of values from one tree into another", async () => {
-    const objectCache = new ObjectTree({});
+    const objectCache = new SyncMap();
     const fixture = await cache(
-      new DeepObjectTree({
+      new DeepObjectMap({
         a: 1,
         b: 2,
         c: 3,
@@ -18,8 +20,8 @@ describe("cache", () => {
       objectCache
     );
 
-    const keys = [...(await fixture.keys())];
-    assert.deepEqual(keys, ["a", "b", "c", "more/"]);
+    const treeKeys = await keys(fixture);
+    assert.deepEqual(treeKeys, ["a", "b", "c", "more/"]);
 
     assert.equal(await objectCache.get("a"), undefined);
     assert.equal(await fixture.get("a"), 1);
@@ -31,7 +33,7 @@ describe("cache", () => {
 
     assert.equal(await objectCache.get("more"), undefined);
     const more = await fixture.get("more");
-    assert.deepEqual([...(await more.keys())], ["d"]);
+    assert.deepEqual([...(await keys(more))], ["d"]);
     assert.equal(await more.get("d"), 4);
     const moreCache = await objectCache.get("more");
     assert.equal(await moreCache.get("d"), 4);

package/test/operations/cachedKeyFunctions.test.js

@@ -1,12 +1,13 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+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";
 
 describe("cachedKeyFunctions", () => {
   test("maps keys with caching", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
       b: "letter b",
     });
@@ -41,7 +42,7 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("maps keys with caching and deep option", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: "letter a",
       b: {
         c: "letter c",
@@ -76,7 +77,7 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("preserves trailing slashes if key function does so", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
     });
     const addUnderscore = async (sourceValue, sourceKey) => `_${sourceKey}`;
@@ -90,7 +91,7 @@ describe("cachedKeyFunctions", () => {
   });
 
   test("if key function toggles slash, defers to key function slash handling", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: "letter a",
     });
     const addUnderscoreAndSlash = async (sourceValue, sourceKey) =>

package/test/operations/clear.test.js

@@ -1,34 +1,13 @@
 import assert from "node:assert";
-import * as fs from "node:fs/promises";
-import path from "node:path";
 import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
-import FileTree from "../../src/drivers/FileTree.js";
-import { ObjectTree, Tree } from "../../src/internal.js";
-
-const dirname = path.dirname(fileURLToPath(import.meta.url));
-const tempDirectory = path.join(dirname, "fixtures/temp");
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import clear from "../../src/operations/clear.js";
+import plain from "../../src/operations/plain.js";
 
 describe("clear", () => {
   test("unsets all public keys in an object tree", async () => {
-    const tree = new ObjectTree({ a: 1, b: 2, c: 3 });
-    await Tree.clear(tree);
-    assert.deepEqual(await Tree.plain(tree), {});
-  });
-
-  test("unsets all public keys in a file tree", async () => {
-    // Create a temp directory with some files
-    await fs.mkdir(tempDirectory, { recursive: true });
-    await fs.writeFile(path.join(tempDirectory, "a"), "1");
-    await fs.writeFile(path.join(tempDirectory, "b"), "2");
-
-    const tree = new FileTree(tempDirectory);
-    await Tree.clear(tree);
-
-    const files = await fs.readdir(tempDirectory);
-    assert.deepEqual(files, []);
-
-    // Remove temp directory
-    await fs.rm(tempDirectory, { recursive: true });
+    const tree = new ObjectMap({ a: 1, b: 2, c: 3 });
+    await clear(tree);
+    assert.deepEqual(await plain(tree), {});
   });
 });

package/test/operations/deepEntries.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import deepEntries from "../../src/operations/deepEntries.js";
+import SampleAsyncMap from "../SampleAsyncMap.js";
+
+describe("deepEntries", () => {
+  test("converts an async tree to an array of nested entries arrays", async () => {
+    const fixture = new SampleAsyncMap([
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+    const result = await deepEntries(fixture);
+    assert.deepStrictEqual(result, [
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+  });
+});

package/test/operations/deepMerge.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 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({
+    const fixture = await deepMerge(
+      new DeepObjectMap({
         a: {
           b: 0, // Will be obscured by `b` below
           c: {
@@ -14,7 +15,7 @@ describe("mergeDeep", () => {
           },
         },
       }),
-      new DeepObjectTree({
+      new DeepObjectMap({
         a: {
           b: 1,
           c: {
@@ -24,7 +25,7 @@ describe("mergeDeep", () => {
         },
       })
     );
-    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,32 @@
 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 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 DeepObjectMap);
   });
 
-  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 +34,20 @@ describe("from", () => {
     };
     Object.defineProperty(obj, symbols.deep, { value: true });
     const tree = from(obj);
-    assert(tree instanceof DeepObjectTree);
+    assert(tree instanceof DeepObjectMap);
   });
 
-  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.only("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,11 +1,12 @@
 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 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({
+    const obj = new DeepObjectMap({
       a: 1,
       b: {
         c: 2,
@@ -19,8 +20,7 @@ describe("inners", () => {
       },
     });
     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()));
+  });
+});