@weborigami/async-tree 0.0.58 → 0.0.60

package/main.js

@@ -11,14 +11,17 @@ export { default as SiteTree } from "./src/SiteTree.js";
 export { DeepObjectTree, ObjectTree, Tree } from "./src/internal.js";
 export * as keysJson from "./src/keysJson.js";
 export { default as cache } from "./src/operations/cache.js";
+export { default as concat } from "./src/operations/concat.js";
 export { default as deepMerge } from "./src/operations/deepMerge.js";
 export { default as deepTake } from "./src/operations/deepTake.js";
 export { default as deepTakeFn } from "./src/operations/deepTakeFn.js";
 export { default as deepValues } from "./src/operations/deepValues.js";
+export { default as deepValuesIterator } from "./src/operations/deepValuesIterator.js";
 export { default as group } from "./src/operations/group.js";
 export { default as groupFn } from "./src/operations/groupFn.js";
 export { default as map } from "./src/operations/map.js";
 export { default as merge } from "./src/operations/merge.js";
+export { default as scope } from "./src/operations/scope.js";
 export { default as sort } from "./src/operations/sort.js";
 export { default as take } from "./src/operations/take.js";
 export * as symbols from "./src/symbols.js";

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.12.8",
-    "typescript": "5.4.5"
+    "@types/node": "20.14.9",
+    "typescript": "5.5.3"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.58"
+    "@weborigami/types": "0.0.60"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/DeferredTree.js

@@ -20,7 +20,6 @@ export default class DeferredTree {
     this.treePromise = null;
     this._tree = null;
     this._parentUntilLoaded = null;
-    this._scopeUntilLoaded = null;
   }
 
   async get(key) {
@@ -54,25 +53,6 @@ export default class DeferredTree {
     }
   }
 
-  // HACK: The concept of scope is defined in Origami, not at the AsyncTree
-  // level. If a DeferredTree is used to wrap an OrigamiTree, the inner
-  // OrigamiTree will have a `scope` but not a `parent`. If someone asks the
-  // outer deferrred tree for a scope, they'd otherwise get `undefined`, which
-  // is incorrect. As a workaround, we introduce a `scope` getter here that
-  // defers to the inner tree, but we need to find a way to avoid having to
-  // introduce the concept of scope here.
-  get scope() {
-    return /** @type {any} */ (this._tree)?.scope;
-  }
-  set scope(scope) {
-    // As with `parent`, we can defer setting of scope.
-    if (this._tree && !(/** @type {any} */ (this._tree).scope)) {
-      /** @type {any} */ (this._tree).scope = scope;
-    } else {
-      this._scopeUntilLoaded = scope;
-    }
-  }
-
   async tree() {
     if (this._tree) {
       return this._tree;
@@ -82,18 +62,13 @@ export default class DeferredTree {
     this.treePromise ??= this.loadResult().then((treelike) => {
       this._tree = Tree.from(treelike);
       if (this._parentUntilLoaded) {
-        // Now that the tree has been loaded, we can set its parent.
+        // Now that the tree has been loaded, we can set its parent if it hasn't
+        // already been set.
         if (!this._tree.parent) {
           this._tree.parent = this._parentUntilLoaded;
         }
         this._parentUntilLoaded = null;
       }
-      if (this._scopeUntilLoaded) {
-        if (!(/** @type {any} */ (this._tree).scope)) {
-          /** @type {any} */ (this._tree).scope = this._scopeUntilLoaded;
-        }
-        this._scopeUntilLoaded = null;
-      }
       return this._tree;
     });
 

package/src/FileTree.js

@@ -13,6 +13,12 @@ import {
 /**
  * A file system tree via the Node file system API.
  *
+ * File values are returned as Uint8Array instances. The underlying Node fs API
+ * returns file contents as instances of the node-specific Buffer class, but
+ * that class has some incompatible method implementations; see
+ * https://nodejs.org/api/buffer.html#buffers-and-typedarrays. For greater
+ * compatibility, files are returned as standard Uint8Array instances instead.
+ *
  * @typedef {import("@weborigami/types").AsyncMutableTree} AsyncMutableTree
  * @implements {AsyncMutableTree}
  */
@@ -65,8 +71,9 @@ export default class FileTree {
       subtree.parent = this;
       return subtree;
     } else {
-      // Return file contents
-      return fs.readFile(filePath);
+      // Return file contents as a standard Uint8Array.
+      const buffer = await fs.readFile(filePath);
+      return Uint8Array.from(buffer);
     }
   }
 

package/src/operations/cache.js

@@ -68,7 +68,7 @@ export default function treeCache(sourceTreelike, cacheTree, filterTreelike) {
     },
 
     async keys() {
-      keys ??= source.keys();
+      keys ??= await source.keys();
       return keys;
     },
   };

package/src/operations/concat.js

@@ -0,0 +1,20 @@
+import { toString } from "../utilities.js";
+import deepValuesIterator from "./deepValuesIterator.js";
+
+/**
+ * Concatenate the deep text values in a tree.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {import("@weborigami/async-tree").Treelike} treelike
+ */
+export default async function concatTreeValues(treelike) {
+  const strings = [];
+  for await (const value of deepValuesIterator(treelike, { expand: true })) {
+    if (value) {
+      strings.push(toString(value));
+    }
+  }
+  return strings.join("");
+}

package/src/operations/deepMerge.js

@@ -18,15 +18,28 @@ export default function deepMerge(...sources) {
 
       // Check trees for the indicated key in reverse order.
       for (let index = trees.length - 1; index >= 0; index--) {
-        const value = await trees[index].get(key);
+        const tree = trees[index];
+        const value = await tree.get(key);
         if (Tree.isAsyncTree(value)) {
+          if (value.parent === tree) {
+            // Merged tree acts as parent instead of the source tree.
+            value.parent = this;
+          }
           subtrees.unshift(value);
         } else if (value !== undefined) {
           return value;
         }
       }
 
-      return subtrees.length > 0 ? deepMerge(...subtrees) : undefined;
+      if (subtrees.length > 1) {
+        const merged = deepMerge(...subtrees);
+        merged.parent = this;
+        return merged;
+      } else if (subtrees.length === 1) {
+        return subtrees[0];
+      } else {
+        return undefined;
+      }
     },
 
     async isKeyForSubtree(key) {

package/src/operations/deepTakeFn.js

@@ -13,7 +13,7 @@ export default function deepTakeFn(count) {
   return async function deepTakeFn(treelike) {
     const tree = await Tree.from(treelike);
     const { values } = await traverse(tree, count);
-    return values;
+    return Tree.from(values);
   };
 }
 

package/src/operations/deepValues.js

@@ -1,10 +1,19 @@
-import { Tree } from "../internal.js";
+import deepValuesIterator from "./deepValuesIterator.js";
 
 /**
  * Return the in-order exterior values of a tree as a flat array.
  *
  * @param {import("../../index.ts").Treelike} treelike
+ * @param {{ expand?: boolean }} [options]
  */
-export default async function deepValues(treelike) {
-  return Tree.mapReduce(treelike, null, async (values) => values.flat());
+export default async function deepValues(
+  treelike,
+  options = { expand: false }
+) {
+  const iterator = deepValuesIterator(treelike, options);
+  const values = [];
+  for await (const value of iterator) {
+    values.push(value);
+  }
+  return values;
 }

package/src/operations/deepValuesIterator.js

@@ -0,0 +1,31 @@
+import { Tree } from "../internal.js";
+
+/**
+ * Return an iterator that yields all values in a tree, including nested trees.
+ *
+ * If the `expand` option is true, treelike values (but not functions) will be
+ * expanded into nested trees and their values will be yielded.
+ *
+ * @param {import("../../index.ts").Treelike} treelike
+ * @param {{ expand?: boolean }} [options]
+ * @returns {AsyncGenerator<any, void, undefined>}
+ */
+export default async function* deepValuesIterator(
+  treelike,
+  options = { expand: false }
+) {
+  const tree = Tree.from(treelike);
+  for (const key of await tree.keys()) {
+    let value = await tree.get(key);
+
+    // Recurse into child trees, but don't expand functions.
+    const recurse =
+      Tree.isAsyncTree(value) ||
+      (options.expand && typeof value !== "function" && Tree.isTreelike(value));
+    if (recurse) {
+      yield* deepValuesIterator(value, options);
+    } else {
+      yield value;
+    }
+  }
+}

package/src/operations/merge.js

@@ -11,19 +11,22 @@ import { Tree } from "../internal.js";
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @param {import("../../index.ts").Treelike[]} sources
- * @returns {AsyncTree & { description: string }}
+ * @returns {AsyncTree & { description: string, trees: AsyncTree[]}}
  */
 export default function merge(...sources) {
-  let trees = sources.map((treelike) => Tree.from(treelike));
-  let mergeParent;
   return {
     description: "merge",
 
     async get(key) {
       // Check trees for the indicated key in reverse order.
-      for (let index = trees.length - 1; index >= 0; index--) {
-        const value = await trees[index].get(key);
+      for (let index = this.trees.length - 1; index >= 0; index--) {
+        const tree = this.trees[index];
+        const value = await tree.get(key);
         if (value !== undefined) {
+          if (Tree.isAsyncTree(value) && value.parent === tree) {
+            // Merged tree acts as parent instead of the source tree.
+            value.parent = this;
+          }
           return value;
         }
       }
@@ -32,8 +35,8 @@ export default function merge(...sources) {
 
     async isKeyForSubtree(key) {
       // Check trees for the indicated key in reverse order.
-      for (let index = trees.length - 1; index >= 0; index--) {
-        if (await Tree.isKeyForSubtree(trees[index], key)) {
+      for (let index = this.trees.length - 1; index >= 0; index--) {
+        if (await Tree.isKeyForSubtree(this.trees[index], key)) {
           return true;
         }
       }
@@ -43,7 +46,7 @@ export default function merge(...sources) {
     async keys() {
       const keys = new Set();
       // Collect keys in the order the trees were provided.
-      for (const tree of trees) {
+      for (const tree of this.trees) {
         for (const key of await tree.keys()) {
           keys.add(key);
         }
@@ -51,18 +54,6 @@ export default function merge(...sources) {
       return keys;
     },
 
-    get parent() {
-      return mergeParent;
-    },
-    set parent(parent) {
-      mergeParent = parent;
-      trees = sources.map((treelike) => {
-        const tree = Tree.isAsyncTree(treelike)
-          ? Object.create(treelike)
-          : Tree.from(treelike);
-        tree.parent = parent;
-        return tree;
-      });
-    },
+    trees: sources.map((treelike) => Tree.from(treelike)),
   };
 }

package/src/operations/scope.js

@@ -0,0 +1,65 @@
+import { Tree } from "@weborigami/async-tree";
+
+/**
+ * A tree's "scope" is the collection of everything in that tree and all of its
+ * ancestors.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @param {Treelike} treelike
+ * @returns {AsyncTree & {trees: AsyncTree[]}}
+ */
+export default function scope(treelike) {
+  const tree = Tree.from(treelike);
+
+  return {
+    // Starting with this tree, search up the parent hierarchy.
+    async get(key) {
+      /** @type {AsyncTree|null|undefined} */
+      let current = tree;
+      let value;
+      while (current) {
+        value = await current.get(key);
+        if (value !== undefined) {
+          break;
+        }
+        current = current.parent;
+      }
+      return value;
+    },
+
+    // Collect all keys for this tree and all parents
+    async keys() {
+      const keys = new Set();
+
+      /** @type {AsyncTree|null|undefined} */
+      let current = tree;
+      while (current) {
+        for (const key of await current.keys()) {
+          keys.add(key);
+        }
+        current = current.parent;
+      }
+
+      return keys;
+    },
+
+    // Collect all keys for this tree and all parents.
+    //
+    // This method exists for debugging purposes, as it's helpful to be able to
+    // quickly flatten and view the entire scope chain.
+    get trees() {
+      const result = [];
+
+      /** @type {AsyncTree|null|undefined} */
+      let current = tree;
+      while (current) {
+        result.push(current);
+        current = current.parent;
+      }
+
+      return result;
+    },
+  };
+}

package/src/transforms/regExpKeys.js

@@ -56,7 +56,9 @@ export default async function regExpKeys(treelike) {
     let value = await tree.get(key);
     if (Tree.isAsyncTree(value)) {
       value = regExpKeys(value);
-      value.parent = result;
+      if (!value.parent) {
+        value.parent = result;
+      }
     }
 
     map.set(regExp, value);

package/src/utilities.d.ts

@@ -10,4 +10,5 @@ export function isStringLike(object: any): object is StringLike;
 export function keysFromPath(path: string): string[];
 export const naturalOrder: (a: string, b: string) => number;
 export function pipeline(start: any, ...functions: Function[]): Promise<any>;
-export function toString(object: any): string;
+export function toPlainValue(object: any): Promise<any>;
+export function toString(object: any): string;

package/src/utilities.js

@@ -1,3 +1,5 @@
+import { Tree } from "./internal.js";
+
 const textDecoder = new TextDecoder();
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 
@@ -56,7 +58,6 @@ export function isPacked(object) {
   return (
     typeof object === "string" ||
     object instanceof ArrayBuffer ||
-    object instanceof Buffer ||
     object instanceof ReadableStream ||
     object instanceof String ||
     object instanceof TypedArray
@@ -89,6 +90,20 @@ export function isPlainObject(object) {
   return Object.getPrototypeOf(object) === getRealmObjectPrototype(object);
 }
 
+/**
+ * Return true if the value is a primitive JavaScript value.
+ *
+ * @param {any} value
+ */
+export function isPrimitive(value) {
+  // Check for null first, since typeof null === "object".
+  if (value === null) {
+    return true;
+  }
+  const type = typeof value;
+  return type !== "object" && type !== "function";
+}
+
 /**
  * Return true if the object is a string or object with a non-trival `toString`
  * method.
@@ -155,6 +170,72 @@ export async function pipeline(start, ...fns) {
   return fns.reduce(async (acc, fn) => fn(await acc), start);
 }
 
+/**
+ * Convert the given input to the plainest possible JavaScript value. This
+ * helper is intended for functions that want to accept an argument from the ori
+ * CLI, which could a string, a stream of data, or some other kind of JavaScript
+ * object.
+ *
+ * If the input is a function, it will be invoked and its result will be
+ * processed.
+ *
+ * If the input is a promise, it will be resolved and its result will be
+ * processed.
+ *
+ * If the input is treelike, it will be converted to a plain JavaScript object,
+ * recursively traversing the tree and converting all values to plain types.
+ *
+ * If the input is stringlike, its text will be returned.
+ *
+ * If the input is a ArrayBuffer or typed array, it will be interpreted as UTF-8
+ * text if it does not contain unprintable characters. If it does, it will be
+ * returned as a base64-encoded string.
+ *
+ * If the input has a custom class instance, its public properties will be
+ * returned as a plain object.
+ *
+ * @param {any} input
+ * @returns {Promise<any>}
+ */
+export async function toPlainValue(input) {
+  if (input instanceof Function) {
+    // Invoke function
+    input = input();
+  }
+  if (input instanceof Promise) {
+    // Resolve promise
+    input = await input;
+  }
+
+  if (isPrimitive(input) || input instanceof Date) {
+    return input;
+  } else if (Tree.isTreelike(input)) {
+    const mapped = await Tree.map(input, (value) => toPlainValue(value));
+    return Tree.plain(mapped);
+  } else if (isStringLike(input)) {
+    return toString(input);
+  } else if (input instanceof ArrayBuffer || input instanceof TypedArray) {
+    // Try to interpret the buffer as UTF-8 text, otherwise use base64.
+    const text = toString(input);
+    if (text !== null) {
+      return text;
+    } else {
+      return toBase64(input);
+    }
+  } else {
+    // Some other kind of class instance; return its public properties.
+    const plain = {};
+    for (const [key, value] of Object.entries(input)) {
+      plain[key] = await toPlainValue(value);
+    }
+    return plain;
+  }
+}
+
+function toBase64(object) {
+  return Buffer.from(object).toString("base64");
+}
+
 /**
  * Return a string form of the object, handling cases not generally handled by
  * the standard JavaScript `toString()` method:
@@ -164,6 +245,10 @@ export async function pipeline(start, ...fns) {
  *    default toString() method, return null instead of "[object Object]". In
  *    practice, it's generally more useful to have this method fail than to
  *    return a useless string.
+ * 3. If the object is a defined primitive value, return the result of
+ *    String(object).
+ *
+ * Otherwise return null.
  *
  * @param {any} object
  * @returns {string|null}
@@ -176,7 +261,7 @@ export function toString(object) {
     // https://stackoverflow.com/a/1677660/76472
     const hasNonPrintableCharacters = /[\x00-\x08\x0E-\x1F]/.test(decoded);
     return hasNonPrintableCharacters ? null : decoded;
-  } else if (isStringLike(object)) {
+  } else if (isStringLike(object) || (object !== null && isPrimitive(object))) {
     return String(object);
   } else {
     return null;

package/test/DeepObjectTree.test.js

@@ -15,9 +15,11 @@ describe("DeepObjectTree", () => {
     const object = await tree.get("object");
     assert.equal(object instanceof DeepObjectTree, true);
     assert.deepEqual(await Tree.plain(object), { b: 2 });
+    assert.equal(object.parent, tree);
 
     const array = await tree.get("array");
     assert.equal(array instanceof DeepObjectTree, true);
     assert.deepEqual(await Tree.plain(array), [3]);
+    assert.equal(array.parent, tree);
   });
 });

package/test/FileTree.test.js

@@ -9,6 +9,8 @@ import { Tree } from "../src/internal.js";
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const tempDirectory = path.join(dirname, "fixtures/temp");
 
+const textDecoder = new TextDecoder();
+
 describe.only("FileTree", async () => {
   test("can get the keys of the tree", async () => {
     const fixture = createFixture("fixtures/markdown");
@@ -21,8 +23,9 @@ describe.only("FileTree", async () => {
 
   test("can get the value for a key", async () => {
     const fixture = createFixture("fixtures/markdown");
-    const alice = await fixture.get("Alice.md");
-    assert.equal(alice, "Hello, **Alice**.");
+    const buffer = await fixture.get("Alice.md");
+    const text = textDecoder.decode(buffer);
+    assert.equal(text, "Hello, **Alice**.");
   });
 
   test("getting an unsupported key returns undefined", async () => {
@@ -95,7 +98,9 @@ describe.only("FileTree", async () => {
 
     // Read them back in.
     const actualFiles = await tempFiles.get("folder");
-    const strings = Tree.map(actualFiles, (buffer) => String(buffer));
+    const strings = Tree.map(actualFiles, (buffer) =>
+      textDecoder.decode(buffer)
+    );
     const plain = await Tree.plain(strings);
     assert.deepEqual(plain, obj);
 

package/test/SiteTree.test.js

@@ -3,6 +3,9 @@ import { beforeEach, describe, mock, test } from "node:test";
 import SiteTree from "../src/SiteTree.js";
 import { Tree } from "../src/internal.js";
 
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
 const mockHost = "https://mock";
 
 const mockResponses = {
@@ -53,8 +56,9 @@ describe("SiteTree", () => {
   test("can get the value for a key", async () => {
     const fixture = new SiteTree(mockHost);
     const about = fixture.resolve("about");
-    const alice = await about.get("Alice.html");
-    assert.equal(alice, "Hello, Alice!");
+    const arrayBuffer = await about.get("Alice.html");
+    const text = textDecoder.decode(arrayBuffer);
+    assert.equal(text, "Hello, Alice!");
   });
 
   test("getting an unsupported key returns undefined", async () => {
@@ -78,7 +82,7 @@ describe("SiteTree", () => {
   test("can convert a SiteGraph to a plain object", async () => {
     const fixture = new SiteTree(mockHost);
     // Convert buffers to strings.
-    const strings = Tree.map(fixture, (value) => value.toString());
+    const strings = Tree.map(fixture, (value) => textDecoder.decode(value));
     assert.deepEqual(await Tree.plain(strings), {
       about: {
         "Alice.html": "Hello, Alice!",
@@ -98,8 +102,7 @@ async function mockFetch(href) {
   if (mockedResponse) {
     return Object.assign(
       {
-        // Returns a Buffer, not an ArrayBuffer
-        arrayBuffer: () => Buffer.from(mockedResponse.data),
+        arrayBuffer: () => textEncoder.encode(mockedResponse.data).buffer,
         ok: true,
         status: 200,
         text: () => mockedResponse.data,

package/test/operations/concat.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import FunctionTree from "../../src/FunctionTree.js";
+import { Tree } from "../../src/internal.js";
+import concat from "../../src/operations/concat.js";
+
+describe("concat", () => {
+  test("concatenates deep tree values", async () => {
+    const tree = Tree.from({
+      a: "A",
+      b: "B",
+      c: "C",
+      more: {
+        d: "D",
+        e: "E",
+      },
+    });
+    const result = await concat.call(null, tree);
+    assert.equal(result, "ABCDE");
+  });
+
+  test("concatenates deep tree-like values", async () => {
+    const letters = ["a", "b", "c"];
+    const specimens = new FunctionTree(
+      (letter) => ({
+        lowercase: letter,
+        uppercase: letter.toUpperCase(),
+      }),
+      letters
+    );
+    const result = await concat.call(null, specimens);
+    assert.equal(result, "aAbBcC");
+  });
+});

package/test/operations/deepMerge.test.js

@@ -34,5 +34,9 @@ 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/deepTakeFn.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
 import deepTakeFn from "../../src/operations/deepTakeFn.js";
 
 describe("deepTakeFn", () => {
@@ -16,6 +17,6 @@ describe("deepTakeFn", () => {
       g: 5,
     };
     const result = await deepTakeFn(4)(tree);
-    assert.deepEqual(result, [1, 2, 3, 4]);
+    assert.deepEqual(await Tree.plain(result), [1, 2, 3, 4]);
   });
 });

package/test/operations/deepValuesIterator.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { ObjectTree } from "../../src/internal.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({
+      a: 1,
+      b: 2,
+      more: {
+        c: 3,
+        d: 4,
+      },
+    });
+    const values = [];
+    // The tree will be shallow, but we'll ask to expand the values.
+    for await (const value of deepValuesIterator(tree, { expand: true })) {
+      values.push(value);
+    }
+    assert.deepEqual(values, [1, 2, 3, 4]);
+  });
+});

package/test/operations/merge.test.js

@@ -33,7 +33,12 @@ 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 Tree.traverse(fixture, "b");
+    assert.equal(b.parent, fixture);
   });
 });

package/test/operations/scope.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { ObjectTree } from "../../src/internal.js";
+import scope from "../../src/operations/scope.js";
+
+describe("scope", () => {
+  test("gets the first defined value from the scope trees", async () => {
+    const outer = new ObjectTree({
+      a: 1,
+      b: 2,
+    });
+    const inner = new ObjectTree({
+      a: 3,
+    });
+    inner.parent = outer;
+    const innerScope = scope(inner);
+    assert.deepEqual([...(await innerScope.keys())], ["a", "b"]);
+    // Inner tree has precedence
+    assert.equal(await innerScope.get("a"), 3);
+    // If tree doesn't have value, finds value from parent
+    assert.equal(await innerScope.get("b"), 2);
+    assert.equal(await innerScope.get("c"), undefined);
+    assert.deepEqual(innerScope.trees, [inner, outer]);
+  });
+});

package/test/transforms/deepReverse.test.js

@@ -1,6 +1,6 @@
-import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
 import deepReverse from "../../src/transforms/deepReverse.js";
 
 describe("deepReverse", () => {

package/test/transforms/reverse.test.js

@@ -1,6 +1,6 @@
-import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
 import reverse from "../../src/transforms/reverse.js";
 
 describe("reverse", () => {

package/test/utilities.test.js

@@ -36,6 +36,31 @@ describe("utilities", () => {
     assert.equal(result, 16);
   });
 
+  test("toPlainValue returns the plainest representation of an object", async () => {
+    class User {
+      constructor(name) {
+        this.name = name;
+      }
+    }
+
+    assert.equal(await utilities.toPlainValue(1), 1);
+    assert.equal(await utilities.toPlainValue("string"), "string");
+    assert.deepEqual(await utilities.toPlainValue({ a: 1 }), { a: 1 });
+    assert.equal(
+      await utilities.toPlainValue(new TextEncoder().encode("bytes")),
+      "bytes"
+    );
+    // ArrayBuffer with non-printable characters should be returned as base64
+    assert.equal(
+      await utilities.toPlainValue(new Uint8Array([1, 2, 3]).buffer),
+      "AQID"
+    );
+    assert.equal(await utilities.toPlainValue(async () => "result"), "result");
+    assert.deepEqual(await utilities.toPlainValue(new User("Alice")), {
+      name: "Alice",
+    });
+  });
+
   test("toString returns the value of an object's `toString` method", () => {
     const object = {
       toString: () => "text",
@@ -49,7 +74,7 @@ describe("utilities", () => {
   });
 
   test("toString decodes an ArrayBuffer as UTF-8", () => {
-    const buffer = Buffer.from("text", "utf8");
-    assert.equal(utilities.toString(buffer), "text");
+    const arrayBuffer = new TextEncoder().encode("text").buffer;
+    assert.equal(utilities.toString(arrayBuffer), "text");
   });
 });