@weborigami/async-tree 0.5.3 → 0.5.5

package/test/operations/deepMap.test.js

@@ -0,0 +1,29 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
+import deepMap from "../../src/operations/deepMap.js";
+
+describe("deepMap", () => {
+  test("can map extensions deeply", async () => {
+    const treelike = new DeepObjectTree({
+      "file1.txt": "will be mapped",
+      file2: "won't be mapped",
+      "file3.foo": "won't be mapped",
+      more: {
+        "file4.txt": "will be mapped",
+        "file5.bar": "won't be mapped",
+      },
+    });
+    const fixture = await deepMap.call(null, treelike, {
+      deep: true,
+      extension: ".txt->.upper",
+      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+    });
+    assert.deepEqual(await Tree.plain(fixture), {
+      "file1.upper": "WILL BE MAPPED",
+      more: {
+        "file4.upper": "WILL BE MAPPED",
+      },
+    });
+  });
+});

package/test/operations/deepMerge.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { DeepObjectTree, Tree } from "../../src/internal.js";
-import mergeDeep from "../../src/operations/deepMerge.js";
+import deepMerge from "../../src/operations/deepMerge.js";
 
 describe("mergeDeep", () => {
   test("can merge deep", async () => {
-    const fixture = mergeDeep(
+    const fixture = deepMerge(
       new DeepObjectTree({
         a: {
           b: 0, // Will be obscured by `b` below
@@ -34,9 +34,5 @@ describe("mergeDeep", () => {
         f: 4,
       },
     });
-
-    // Parent of a subvalue is the merged tree
-    const a = await fixture.get("a");
-    assert.equal(a.parent, fixture);
   });
 });

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