@weborigami/async-tree 0.5.4 → 0.5.5

package/test/operations/deepReverse.test.js

@@ -12,7 +12,7 @@ describe("deepReverse", () => {
         d: 3,
       },
     };
-    const reversed = deepReverse.call(null, tree);
+    const reversed = await deepReverse.call(null, tree);
     assert.deepEqual(await Tree.plain(reversed), {
       b: {
         d: 3,

package/test/operations/defineds.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import defineds from "../../src/operations/defineds.js";
+
+describe("defineds", () => {
+  test("returns only defined values in a tree", async () => {
+    const obj = {
+      a: 1,
+      b: undefined,
+      c: null,
+      d: {
+        e: 2,
+        f: undefined,
+        g: {
+          h: 3,
+          i: undefined,
+        },
+      },
+    };
+    const result = await defineds(obj);
+    const plain = await Tree.plain(result);
+    assert.deepEqual(plain, { a: 1, d: { e: 2, g: { h: 3 } } });
+  });
+});

package/test/operations/delete.test.js

@@ -0,0 +1,20 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.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({
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    });
+    await del(fixture, "Alice.md");
+    assert.deepEqual(await plain(fixture), {
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    });
+  });
+});

package/test/operations/entries.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import entries from "../../src/operations/entries.js";
+
+describe("entries", () => {
+  test("entries() returns the [key, value] pairs", async () => {
+    const fixture = {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    };
+    assert.deepEqual(Array.from(await entries(fixture)), [
+      ["Alice.md", "Hello, **Alice**."],
+      ["Bob.md", "Hello, **Bob**."],
+      ["Carol.md", "Hello, **Carol**."],
+    ]);
+  });
+});

package/test/operations/extensionKeyFunctions.test.js

@@ -9,28 +9,28 @@ describe("keyMapsForExtensions", () => {
     const { inverseKey, key } = extensionKeyFunctions(".txt");
     assert.equal(await inverseKey("file.txt"), "file.txt");
     assert.equal(await inverseKey("file.txt/"), "file.txt");
-    assert.equal(await key("file.txt"), "file.txt");
-    assert.equal(await key("file.txt/"), "file.txt/");
+    assert.equal(await key(null, "file.txt"), "file.txt");
+    assert.equal(await key(null, "file.txt/"), "file.txt/");
     assert.equal(await inverseKey("file.foo"), undefined);
-    assert.equal(await key("file.foo"), undefined);
+    assert.equal(await key(null, "file.foo"), undefined);
   });
 
   test("returns key functions that can map extensions", async () => {
     const { inverseKey, key } = extensionKeyFunctions(".md", ".json");
     assert.equal(await inverseKey("file.json"), "file.md");
     assert.equal(await inverseKey("file.json/"), "file.md");
-    assert.equal(await key("file.md"), "file.json");
-    assert.equal(await key("file.md/"), "file.json/");
+    assert.equal(await key(null, "file.md"), "file.json");
+    assert.equal(await key(null, "file.md/"), "file.json/");
     assert.equal(await inverseKey("file.foo"), undefined);
-    assert.equal(await key("file.foo"), undefined);
+    assert.equal(await key(null, "file.foo"), undefined);
   });
 
   test("key functions can handle a slash as an explicit extension", async () => {
     const { inverseKey, key } = extensionKeyFunctions("/", ".html");
     assert.equal(await inverseKey("file.html"), "file/");
     assert.equal(await inverseKey("file.html/"), "file/");
-    assert.equal(await key("file"), undefined);
-    assert.equal(await key("file/"), "file.html");
+    assert.equal(await key(null, "file"), undefined);
+    assert.equal(await key(null, "file/"), "file.html");
   });
 
   test("works with map to handle keys that end in a given resultExtension", async () => {
@@ -40,7 +40,7 @@ describe("keyMapsForExtensions", () => {
       "file3.foo": "won't be mapped",
     });
     const { inverseKey, key } = extensionKeyFunctions(".txt");
-    const fixture = map(files, {
+    const fixture = await map(files, {
       inverseKey,
       key,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
@@ -57,7 +57,7 @@ describe("keyMapsForExtensions", () => {
       "file3.foo": "won't be mapped",
     });
     const { inverseKey, key } = extensionKeyFunctions(".txt", ".upper");
-    const fixture = map(files, {
+    const fixture = await map(files, {
       inverseKey,
       key,
       value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),

package/test/operations/first.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import first from "../../src/operations/first.js";
+
+describe("first", () => {
+  test("returns the first value in the tree", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+    };
+    const result = await first(obj);
+    assert.equal(result, 1);
+  });
+});

package/test/operations/fixtures/README.md

@@ -0,0 +1 @@
+This folder is used as a temp directory by some tests

package/test/operations/forEach.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import forEach from "../../src/operations/forEach.js";
+
+describe("forEach", () => {
+  test("invokes a callback for each entry", async () => {
+    const fixture = {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    };
+    const results = {};
+    await forEach(fixture, async (value, key) => {
+      results[key] = value;
+    });
+    assert.deepEqual(results, {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    });
+  });
+});

package/test/operations/from.test.js

@@ -0,0 +1,67 @@
+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 from from "../../src/operations/from.js";
+import plain from "../../src/operations/plain.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.",
+    });
+    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 () => {
+    const obj = {
+      sub: {
+        a: 1,
+      },
+    };
+    const tree = from(obj, { deep: true });
+    assert(tree instanceof DeepObjectTree);
+  });
+
+  test("returns a deep object tree if object has [deep] symbol set", async () => {
+    const obj = {
+      sub: {
+        a: 1,
+      },
+    };
+    Object.defineProperty(obj, symbols.deep, { value: true });
+    const tree = from(obj);
+    assert(tree instanceof DeepObjectTree);
+  });
+
+  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("autoboxes primitive values", async () => {
+    const tree = from("Hello, world.");
+    const slice = await tree.get("slice");
+    const result = await slice(0, 5);
+    assert.equal(result, "Hello");
+  });
+});

package/test/operations/globKeys.test.js

@@ -5,7 +5,7 @@ import globKeys from "../../src/operations/globKeys.js";
 
 describe("globKeys", () => {
   test("matches globs", async () => {
-    const globTree = globKeys({
+    const globTree = await globKeys({
       "*.txt": true,
       "*.js": false,
       "*.jsx": true,
@@ -20,7 +20,7 @@ describe("globKeys", () => {
   });
 
   test("matches nested globs", async () => {
-    const globTree = globKeys({
+    const globTree = await globKeys({
       sub: {
         foo: "bar",
         "*": "default",
@@ -31,7 +31,7 @@ describe("globKeys", () => {
   });
 
   test("supports deep matches with globstar", async () => {
-    const globTree = globKeys({
+    const globTree = await globKeys({
       "**": {
         "*.txt": true, // More specific glob pattern must come
         "*": false,

package/test/operations/has.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import has from "../../src/operations/has.js";
+
+describe("has", () => {
+  test("has returns true if the key exists", async () => {
+    const fixture = {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    };
+    assert.equal(await has(fixture, "Alice.md"), true);
+    assert.equal(await has(fixture, "David.md"), false);
+  });
+});

package/test/operations/inners.test.js

@@ -0,0 +1,30 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
+import inners from "../../src/operations/inners.js";
+
+describe("inners", () => {
+  test("returns the interior nodes of a tree", async () => {
+    const obj = new DeepObjectTree({
+      a: 1,
+      b: {
+        c: 2,
+        d: {
+          e: 3,
+        },
+      },
+      f: 4,
+      g: {
+        h: 5,
+      },
+    });
+    const result = await inners(obj);
+    const plain = await Tree.plain(result);
+    assert.deepEqual(plain, {
+      b: {
+        d: {},
+      },
+      g: {},
+    });
+  });
+});

package/test/operations/invokeFunctions.test.js

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

package/test/operations/isAsyncMutableTree.test.js

@@ -0,0 +1,17 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import isAsyncMutableTree from "../../src/operations/isAsyncMutableTree.js";
+
+describe("isAsyncMutableTree", () => {
+  test("returns true if the object is a mutable tree", () => {
+    assert.equal(
+      isAsyncMutableTree({
+        get() {},
+        keys() {},
+      }),
+      false
+    );
+    assert.equal(isAsyncMutableTree(new ObjectTree({})), true);
+  });
+});

package/test/operations/isAsyncTree.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import isAsyncTree from "../../src/operations/isAsyncTree.js";
+
+describe("isAsyncTree", () => {
+  test("returns true if the object is a tree", () => {
+    const missingGetAndKeys = {};
+    assert(!isAsyncTree(missingGetAndKeys));
+
+    const missingIterator = {
+      async get() {},
+    };
+    assert(!isAsyncTree(missingIterator));
+
+    const missingGet = {
+      async keys() {},
+    };
+    assert(!isAsyncTree(missingGet));
+
+    const hasGetAndKeys = {
+      async get() {},
+      async keys() {},
+    };
+    assert(isAsyncTree(hasGetAndKeys));
+  });
+});

package/test/operations/isTreelike.test.js

@@ -0,0 +1,13 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import isTreelike from "../../src/operations/isTreelike.js";
+
+describe("Fixture name goes here", () => {
+  test("isTreelike() returns true if the argument can be cast to an async tree", () => {
+    assert(!isTreelike(null));
+    assert(isTreelike({}));
+    assert(isTreelike([]));
+    assert(isTreelike(new Map()));
+    assert(isTreelike(new Set()));
+  });
+});

package/test/operations/keys.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import keys from "../../src/operations/keys.js";
+
+describe("keys", () => {
+  test("returns the keys of a tree as an array", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+    };
+    const result = await keys(obj);
+    assert.deepEqual(result, ["a", "b", "c"]);
+  });
+});

package/test/operations/length.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import length from "../../src/operations/length.js";
+
+describe("length", () => {
+  test("returns the number of keys in the tree", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+    };
+    const result = await length(obj);
+    assert.equal(result, 3);
+  });
+});

package/test/operations/map.test.js

@@ -1,6 +1,5 @@
 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";
@@ -11,8 +10,8 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    assert.throws(() => {
-      map(tree, {});
+    assert.rejects(async () => {
+      await map(tree, {});
     });
   });
 
@@ -22,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);
@@ -41,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();
     });
@@ -56,7 +55,7 @@ describe("map", () => {
       a: "letter a",
       b: "letter b",
     };
-    const underscoreKeys = map(tree, {
+    const underscoreKeys = await map(tree, {
       key: addUnderscore,
       inverseKey: removeUnderscore,
     });
@@ -71,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), {
@@ -81,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,
     });
   });
 
@@ -103,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,
     });
@@ -122,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",
@@ -136,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(),
     });
@@ -155,7 +155,7 @@ describe("map", () => {
         b: "letter b",
       },
     });
-    const underscoreKeys = map(tree, {
+    const underscoreKeys = await map(tree, {
       deep: true,
       key: addUnderscore,
       inverseKey: removeUnderscore,
@@ -175,7 +175,7 @@ describe("map", () => {
         b: "letter b",
       },
     });
-    const underscoreKeysUppercaseValues = map(tree, {
+    const underscoreKeysUppercaseValues = await map(tree, {
       deep: true,
       key: addUnderscore,
       inverseKey: removeUnderscore,
@@ -189,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",
@@ -222,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,