@weborigami/async-tree 0.5.4 → 0.5.6

package/test/operations/match.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import match from "../../src/operations/match.js";
+
+describe("match", () => {
+  test("matches keys against a simplified pattern", async () => {
+    function fn(matches) {
+      return `Hello, ${matches.name}!`;
+    }
+    const tree = match("[name].html", fn, [
+      "Alice.html",
+      "Bob.html",
+      "Carol.html",
+    ]);
+    assert.deepEqual(await Tree.plain(tree), {
+      "Alice.html": "Hello, Alice!",
+      "Bob.html": "Hello, Bob!",
+      "Carol.html": "Hello, Carol!",
+    });
+    const value = await tree.get("David.html");
+    assert.equal(value, "Hello, David!");
+  });
+
+  test("matches keys against a regular expression", async () => {
+    function fn(matches) {
+      return `Hello, ${matches.name}!`;
+    }
+    const tree = match(/^(?<name>.+)\.html$/, fn);
+    const value = await tree.get("Alice.html");
+    assert.equal(value, "Hello, Alice!");
+  });
+});

package/test/operations/merge.test.js

@@ -2,26 +2,25 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import merge from "../../src/operations/merge.js";
-import * as symbols from "../../src/symbols.js";
 
 describe("merge", () => {
   test("performs a shallow merge", async () => {
     const fixture = merge(
-      {
+      new ObjectTree({
         a: 1,
         // Will be obscured by `b` that follows
         b: {
           c: 2,
         },
-      },
-      {
+      }),
+      new ObjectTree({
         b: {
           d: 3,
         },
         e: {
           f: 4,
         },
-      }
+      })
     );
 
     assert.deepEqual(await Tree.plain(fixture), {
@@ -37,10 +36,6 @@ describe("merge", () => {
     // Merge is shallow, and last tree wins, so `b/c` doesn't exist
     const c = await Tree.traverse(fixture, "b", "c");
     assert.equal(c, undefined);
-
-    // Parent of a subvalue is the merged tree
-    const b = await fixture.get("b");
-    assert.equal(b[symbols.parent], fixture);
   });
 
   test("subtree can overwrite a leaf node", async () => {
@@ -61,4 +56,23 @@ describe("merge", () => {
       },
     });
   });
+
+  test("if all arguments are plain objects, result is a plain object", async () => {
+    const result = await merge(
+      {
+        a: 1,
+        b: 2,
+      },
+      {
+        c: 3,
+        d: 4,
+      }
+    );
+    assert.deepEqual(result, {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+    });
+  });
 });

package/test/operations/paginate.test.js

@@ -12,7 +12,7 @@ describe("paginate", () => {
       d: 4,
       e: 5,
     };
-    const paginated = await paginate.call(null, treelike, 2);
+    const paginated = await paginate(treelike, 2);
     const plain = await Tree.plain(paginated);
     assert.deepEqual(await plain, {
       1: {

package/test/operations/parent.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { ObjectTree } from "../../src/internal.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 sub = await tree.get("sub");
+    const result = await parent(sub);
+    assert.equal(result, tree);
+  });
+});

package/test/operations/paths.test.js

@@ -0,0 +1,40 @@
+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 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({
+      a: 1,
+      b: 2,
+      c: {
+        d: 3,
+        e: 4,
+      },
+    });
+    assert.deepEqual(await paths(tree), ["a", "b", "c/d", "c/e"]);
+  });
+
+  test("can focus just on keys with trailing slashes", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      b: 2,
+      // This is a shallow ObjectTree, so `c` won't have a trailing slash
+      c: {
+        d: 3,
+      },
+      // Explicitly include a trailing slash to signal a subtree
+      "d/": new ObjectTree({
+        e: 4,
+      }),
+    });
+    assert.deepEqual(await paths(tree, { assumeSlashes: true }), [
+      "a",
+      "b",
+      "c",
+      "d/e",
+    ]);
+  });
+});

package/test/operations/plain.test.js

@@ -0,0 +1,69 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import plain from "../../src/operations/plain.js";
+
+describe("plain", () => {
+  test("produces a plain object version of a tree", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      // Slashes should be normalized
+      "sub1/": {
+        b: 2,
+      },
+      sub2: {
+        c: 3,
+      },
+    });
+    assert.deepEqual(await plain(tree), {
+      a: 1,
+      sub1: {
+        b: 2,
+      },
+      sub2: {
+        c: 3,
+      },
+    });
+  });
+
+  test("produces an array for an array-like tree", async () => {
+    const original = ["a", "b", "c"];
+    const tree = new ObjectTree(original);
+    assert.deepEqual(await plain(tree), original);
+  });
+
+  test("leaves an array-like tree as an object if keys aren't consecutive", async () => {
+    const original = {
+      0: "a",
+      1: "b",
+      // missing
+      3: "c",
+    };
+    const tree = new ObjectTree(original);
+    assert.deepEqual(await plain(tree), original);
+  });
+
+  test("returns empty array or object for ObjectTree as necessary", async () => {
+    const tree = new ObjectTree({});
+    assert.deepEqual(await plain(tree), {});
+    const arrayTree = new ObjectTree([]);
+    assert.deepEqual(await plain(arrayTree), []);
+  });
+
+  test("awaits async properties", async () => {
+    const object = {
+      get name() {
+        return Promise.resolve("Alice");
+      },
+    };
+    assert.deepEqual(await plain(object), { name: "Alice" });
+  });
+
+  test("coerces TypedArray values to strings", async () => {
+    const tree = new ObjectTree({
+      a: new TextEncoder().encode("Hello, world."),
+    });
+    const result = await plain(tree);
+    assert.equal(result.a, "Hello, world.");
+  });
+});

package/test/operations/reverse.test.js

@@ -10,7 +10,7 @@ describe("reverse", () => {
       b: "B",
       c: "C",
     };
-    const reversed = reverse.call(null, tree);
+    const reversed = await reverse(tree);
     // @ts-ignore
     assert.deepEqual(Array.from(await reversed.keys()), ["c", "b", "a"]);
     // @ts-ignore

package/test/operations/scope.test.js

@@ -13,7 +13,7 @@ describe("scope", () => {
       a: 3,
     });
     inner.parent = outer;
-    const innerScope = scope(inner);
+    const innerScope = await scope(inner);
     assert.deepEqual([...(await innerScope.keys())], ["a", "b"]);
     // Inner tree has precedence
     assert.equal(await innerScope.get("a"), 3);

package/test/operations/shuffle.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import shuffle from "../../src/operations/shuffle.js";
+
+describe("shuffle", () => {
+  test("shuffles the keys of a tree", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+      e: 5,
+    };
+    const result = await shuffle(obj);
+    const keys = Array.from(await result.keys());
+    assert.deepEqual(keys.sort(), Object.keys(obj).sort());
+  });
+});

package/test/operations/sort.test.js

@@ -10,7 +10,7 @@ describe("sort", () => {
       file1: null,
       file9: null,
     });
-    const sorted = sort(tree);
+    const sorted = await sort(tree);
     assert.deepEqual(Array.from(await sorted.keys()), [
       "file1",
       "file10",
@@ -26,7 +26,7 @@ describe("sort", () => {
     });
     // Reverse order
     const compare = (a, b) => (a > b ? -1 : a < b ? 1 : 0);
-    const sorted = sort(tree, { compare });
+    const sorted = await sort(tree, { compare });
     assert.deepEqual(Array.from(await sorted.keys()), ["c", "b", "a"]);
   });
 
@@ -37,7 +37,7 @@ describe("sort", () => {
       Carol: { age: 42 },
     };
     const sorted = await sort(tree, {
-      sortKey: async (key, tree) => Tree.traverse(tree, key, "age"),
+      sortKey: async (value, key, tree) => value.age,
     });
     assert.deepEqual(Array.from(await sorted.keys()), [
       "Bob",

package/test/operations/toFunction.test.js

@@ -0,0 +1,16 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import toFunction from "../../src/operations/toFunction.js";
+
+describe("toFunction", () => {
+  test("returns a function that invokes a tree's get() method", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      b: 2,
+    });
+    const fn = await toFunction(tree);
+    assert.equal(await fn("a"), 1);
+    assert.equal(await fn("b"), 2);
+  });
+});

package/test/operations/traverse.test.js

@@ -0,0 +1,43 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import MapTree from "../../src/drivers/MapTree.js";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import traverse from "../../src/operations/traverse.js";
+
+describe("traverse", () => {
+  test("traverses a path of keys", async () => {
+    const tree = new ObjectTree({
+      a1: 1,
+      a2: {
+        b1: 2,
+        b2: {
+          c1: 3,
+          c2: 4,
+        },
+      },
+    });
+    assert.equal(await traverse(tree), tree);
+    assert.equal(await traverse(tree, "a1"), 1);
+    assert.equal(await traverse(tree, "a2", "b2", "c2"), 4);
+    assert.equal(await traverse(tree, "a2", "doesntexist", "c2"), undefined);
+  });
+
+  test("traverses a function with fixed number of arguments", async () => {
+    const tree = (a, b) => ({
+      c: "Result",
+    });
+    assert.equal(await traverse(tree, "a", "b", "c"), "Result");
+  });
+
+  test("traverses from one tree into another", async () => {
+    const tree = new ObjectTree({
+      a: {
+        b: new MapTree([
+          ["c", "Hello"],
+          ["d", "Goodbye"],
+        ]),
+      },
+    });
+    assert.equal(await traverse(tree, "a", "b", "c"), "Hello");
+  });
+});

package/test/operations/traversePath.test.js

@@ -0,0 +1,16 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import traversePath from "../../src/operations/traversePath.js";
+
+describe("traversePath", () => {
+  test("traversePath() traverses a slash-separated path", async () => {
+    const tree = {
+      a: {
+        b: {
+          c: "Hello",
+        },
+      },
+    };
+    assert.equal(await traversePath(tree, "a/b/c"), "Hello");
+  });
+});

package/test/operations/values.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import values from "../../src/operations/values.js";
+
+describe("values", () => {
+  test("returns the tree's values as an array", async () => {
+    const fixture = {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    };
+    assert.deepEqual(await values(fixture), [
+      "Hello, **Alice**.",
+      "Hello, **Bob**.",
+      "Hello, **Carol**.",
+    ]);
+  });
+});

package/test/operations/withKeys.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import withKeys from "../../src/operations/withKeys.js";
+
+describe("withKeys", () => {
+  test("applies the indicated keys", async () => {
+    const result = await withKeys(
+      {
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+      ["a", "c"]
+    );
+    assert.deepEqual(await Tree.plain(result), {
+      a: 1,
+      c: 3,
+    });
+  });
+});

package/test/utilities/box.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import box from "../../src/utilities/box.js";
+
+describe("box", () => {
+  test("returns a boxed value", () => {
+    const string = "string";
+    const stringObject = box(string);
+    assert(stringObject instanceof String);
+    assert.equal(stringObject, string);
+
+    const number = 1;
+    const numberObject = box(number);
+    assert(numberObject instanceof Number);
+    assert.equal(numberObject, number);
+
+    const boolean = true;
+    const booleanObject = box(boolean);
+    assert(booleanObject instanceof Boolean);
+    assert.equal(booleanObject, boolean);
+
+    const object = {};
+    const boxedObject = box(object);
+    assert.equal(boxedObject, object);
+  });
+});

package/test/utilities/getRealmObjectPrototype.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import getRealmObjectPrototype from "../../src/utilities/getRealmObjectPrototype.js";
+
+describe("getRealmObjectPrototype", () => {
+  test("returns the object's root prototype", () => {
+    const object = {};
+    const proto = getRealmObjectPrototype(object);
+    assert.equal(proto, Object.prototype);
+  });
+});

package/test/utilities/isPlainObject.test.js

@@ -0,0 +1,13 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import isPlainObject from "../../src/utilities/isPlainObject.js";
+
+describe("isPlainObject", () => {
+  test("returns true if the object is a plain object", () => {
+    assert.equal(isPlainObject({}), true);
+    assert.equal(isPlainObject(new Object()), true);
+    assert.equal(isPlainObject(Object.create(null)), true);
+    class Foo {}
+    assert.equal(isPlainObject(new Foo()), false);
+  });
+});

package/test/utilities/keysFromPath.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import keysFromPath from "../../src/utilities/keysFromPath.js";
+
+describe("keysFromPath", () => {
+  test("returns the keys from a slash-separated path", () => {
+    assert.deepEqual(keysFromPath(""), []);
+    assert.deepEqual(keysFromPath("/"), []);
+    assert.deepEqual(keysFromPath("a/b/c"), ["a/", "b/", "c"]);
+    assert.deepEqual(keysFromPath("a/b/c/"), ["a/", "b/", "c/"]);
+    assert.deepEqual(keysFromPath("/foo/"), ["foo/"]);
+    assert.deepEqual(keysFromPath("a///b"), ["a/", "b"]);
+  });
+});

package/test/utilities/naturalOrder.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import naturalOrder from "../../src/utilities/naturalOrder.js";
+
+describe("naturalOrder", () => {
+  test("compares strings in natural order", () => {
+    const strings = ["file10", "file1", "file9"];
+    strings.sort(naturalOrder);
+    assert.deepEqual(strings, ["file1", "file9", "file10"]);
+  });
+});

package/test/utilities/pathFromKeys.test.js

@@ -0,0 +1,12 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import pathFromKeys from "../../src/utilities/pathFromKeys.js";
+
+describe("pathFromKeys", () => {
+  test("returns a slash-separated path from keys", () => {
+    assert.equal(pathFromKeys([]), "");
+    assert.equal(pathFromKeys(["a", "b", "c"]), "a/b/c");
+    assert.equal(pathFromKeys(["a/", "b/", "c"]), "a/b/c");
+    assert.equal(pathFromKeys(["a/", "b/", "c/"]), "a/b/c/");
+  });
+});

package/test/utilities/setParent.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import * as symbols from "../../src/symbols.js";
+import setParent from "../../src/utilities/setParent.js";
+
+describe("setParent", () => {
+  test("sets a child's parent", () => {
+    const parent = new ObjectTree({});
+
+    // Set [symbols.parent] on a plain object.
+    const object = {};
+    setParent(object, parent);
+    assert.equal(object[symbols.parent], parent);
+
+    // Leave [symbols.parent] alone if it's already set.
+    const childWithParent = {
+      [symbols.parent]: "parent",
+    };
+    setParent(childWithParent, parent);
+    assert.equal(childWithParent[symbols.parent], "parent");
+
+    // Set `parent` on a tree.
+    const tree = new ObjectTree({});
+    setParent(tree, parent);
+    assert.equal(tree.parent, parent);
+
+    // Leave `parent` alone if it's already set.
+    const treeWithParent = new ObjectTree({});
+    treeWithParent.parent = "parent";
+    setParent(treeWithParent, parent);
+    assert.equal(treeWithParent.parent, "parent");
+  });
+});

package/test/utilities/toFunction.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import toFunction from "../../src/utilities/toFunction.js";
+
+describe("toFunction", () => {
+  test("returns a plain function as is", () => {
+    const fn = () => {};
+    assert.equal(toFunction(fn), fn);
+  });
+
+  test("returns a tree's getter as a function", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+    });
+    const fn = toFunction(tree);
+    // @ts-ignore
+    assert.equal(await fn("a"), 1);
+  });
+
+  test("can use a packed object's `unpack` as a function", async () => {
+    const obj = new String();
+    /** @type {any} */ (obj).unpack = () => () => "result";
+    const fn = toFunction(obj);
+    // @ts-ignore
+    assert.equal(await fn(), "result");
+  });
+
+  test("returns null for something that's not a function", () => {
+    // @ts-ignore
+    const result = toFunction("this is not a function");
+    assert.equal(result, null);
+  });
+});

package/test/utilities/toPlainValue.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import toPlainValue from "../../src/utilities/toPlainValue.js";
+
+describe("toPlainValue", () => {
+  test("returns the plainest representation of an object", async () => {
+    class User {
+      constructor(name) {
+        this.name = name;
+      }
+    }
+
+    assert.equal(await toPlainValue(1), 1);
+    assert.equal(await toPlainValue("string"), "string");
+    assert.deepEqual(await toPlainValue({ a: 1 }), { a: 1 });
+    assert.equal(
+      await toPlainValue(new TextEncoder().encode("bytes")),
+      "bytes"
+    );
+    // ArrayBuffer with non-printable characters should be returned as base64
+    assert.equal(await toPlainValue(new Uint8Array([1, 2, 3]).buffer), "AQID");
+    assert.equal(await toPlainValue(async () => "result"), "result");
+    assert.deepEqual(await toPlainValue(new User("Alice")), {
+      name: "Alice",
+    });
+  });
+});

package/test/utilities/toString.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import toString from "../../src/utilities/toString.js";
+
+describe("toString", () => {
+  test("returns the value of an object's `toString` method", () => {
+    const object = {
+      toString: () => "text",
+    };
+    assert.equal(toString(object), "text");
+  });
+
+  test("returns null for an object with no useful `toString`", () => {
+    const object = {};
+    assert.equal(toString(object), null);
+  });
+
+  test("decodes an ArrayBuffer as UTF-8", () => {
+    const arrayBuffer = new TextEncoder().encode("text").buffer;
+    assert.equal(toString(arrayBuffer), "text");
+  });
+});

package/src/Tree.d.ts

@@ -1,24 +0,0 @@
-import type { AsyncMutableTree, AsyncTree } from "@weborigami/types";
-import { PlainObject, ReduceFn, Treelike, TreeMapOptions, ValueKeyFn } from "../index.ts";
-
-export function assign(target: Treelike, source: Treelike): Promise<AsyncTree>;
-export function clear(AsyncTree: AsyncMutableTree): Promise<void>;
-export function entries(AsyncTree: AsyncTree): Promise<IterableIterator<any>>;
-export function forEach(AsyncTree: AsyncTree, callbackfn: (value: any, key: any) => Promise<void>): Promise<void>;
-export function from(obj: any, options?: { deep?: boolean, parent?: AsyncTree|null }): AsyncTree;
-export function has(AsyncTree: AsyncTree, key: any): Promise<boolean>;
-export function isAsyncMutableTree(obj: any): obj is AsyncMutableTree;
-export function isAsyncTree(obj: any): obj is AsyncTree;
-export function isTraversable(obj: any): boolean;
-export function isTreelike(obj: any): obj is Treelike;
-export function map(tree: Treelike, options: TreeMapOptions|ValueKeyFn): AsyncTree;
-export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
-export function paths(tree: Treelike, options?: { assumeSlashes?: boolean, base?: string }): string[];
-export function plain(tree: Treelike): Promise<PlainObject>;
-export function root(tree: Treelike): AsyncTree;
-export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;
-export function toFunction(tree: Treelike): Function;
-export function traverse(tree: Treelike, ...keys: any[]): Promise<any>;
-export function traverseOrThrow(tree: Treelike, ...keys: any[]): Promise<any>;
-export function traversePath(tree: Treelike, path: string): Promise<any>;
-export function values(tree: Treelike): Promise<IterableIterator<any>>;