@weborigami/async-tree 0.0.46 → 0.0.48

package/index.ts

@@ -15,6 +15,12 @@ export type HasString = {
   toString(): string;
 };
 
+/**
+ * A packed value is one that can be written to a file via fs.writeFile or into
+ * an HTTP response via response.write, or readily converted to such a form.
+ */
+export type Packed = ArrayBuffer | Buffer | ReadableStream | string | String | TypedArray;
+
 export type PlainObject = {
   [key: string]: any;
 };
@@ -37,6 +43,17 @@ export type Treelike =
 
 export type TreeTransform = (treelike: Treelike) => AsyncTree;
 
+export type TypedArray =
+  Float32Array |
+  Float64Array |
+  Int8Array |
+  Int16Array |
+  Int32Array |
+  Uint8Array |
+  Uint8ClampedArray |
+  Uint16Array |
+  Uint32Array;
+
 export type Unpackable<T> = {
   unpack(): Promise<T>
 };

package/main.js

@@ -4,17 +4,16 @@ export { default as DeferredTree } from "./src/DeferredTree.js";
 export { default as FileTree } from "./src/FileTree.js";
 export { default as FunctionTree } from "./src/FunctionTree.js";
 export { default as MapTree } from "./src/MapTree.js";
-export { default as ObjectTree } from "./src/ObjectTree.js";
 // Skip BrowserFileTree.js, which is browser-only.
 export { default as DeepMapTree } from "./src/DeepMapTree.js";
-export { default as DeepObjectTree } from "./src/DeepObjectTree.js";
 export { default as SetTree } from "./src/SetTree.js";
 export { default as SiteTree } from "./src/SiteTree.js";
-export * as Tree from "./src/Tree.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 merge } from "./src/operations/merge.js";
 export { default as mergeDeep } from "./src/operations/mergeDeep.js";
+export * as symbols from "./src/symbols.js";
 export { default as cachedKeyFunctions } from "./src/transforms/cachedKeyFunctions.js";
 export { default as groupBy } from "./src/transforms/groupBy.js";
 export { default as keyFunctionsForExtensions } from "./src/transforms/keyFunctionsForExtensions.js";

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.11.7",
-    "typescript": "5.3.3"
+    "@types/node": "20.11.27",
+    "typescript": "5.4.2"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.46"
+    "@weborigami/types": "0.0.48"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/BrowserFileTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 import { hiddenFileNames, isStringLike, sortNatural } from "./utilities.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);

package/src/DeepMapTree.js

@@ -1,5 +1,5 @@
+import { Tree } from "./internal.js";
 import MapTree from "./MapTree.js";
-import * as Tree from "./Tree.js";
 
 export default class DeepMapTree extends MapTree {
   async get(key) {

package/src/DeepObjectTree.js

@@ -1,5 +1,4 @@
-import ObjectTree from "./ObjectTree.js";
-import * as Tree from "./Tree.js";
+import { ObjectTree, Tree } from "./internal.js";
 import { isPlainObject } from "./utilities.js";
 
 export default class DeepObjectTree extends ObjectTree {

package/src/DeferredTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 
 /**
  * A tree that is loaded lazily.
@@ -19,7 +19,8 @@ export default class DeferredTree {
     this.loader = loader;
     this.treePromise = null;
     this._tree = null;
-    this._parent = null;
+    this._parentUntilLoaded = null;
+    this._scopeUntilLoaded = null;
   }
 
   async get(key) {
@@ -39,14 +40,17 @@ export default class DeferredTree {
     return tree.keys();
   }
 
+  // A deferred tree's parent generally comes from the loaded tree. However, if
+  // someone tries to get or set the parent before the tree is loaded, we store
+  // that parent reference and apply it once the tree is loaded.
   get parent() {
-    return this._tree?.parent ?? this._parent;
+    return this._tree?.parent ?? this._parentUntilLoaded;
   }
   set parent(parent) {
     if (this._tree && !this._tree.parent) {
       this._tree.parent = parent;
     } else {
-      this._parent = parent;
+      this._parentUntilLoaded = parent;
     }
   }
 
@@ -61,9 +65,11 @@ export default class DeferredTree {
     return /** @type {any} */ (this._tree)?.scope;
   }
   set scope(scope) {
-    // If tree hasn't been loaded yet, setting scope has no effect.
-    if (this._tree) {
+    // 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;
     }
   }
 
@@ -75,11 +81,18 @@ export default class DeferredTree {
     // Use a promise to ensure the treelike is only converted to a tree once.
     this.treePromise ??= this.loadResult().then((treelike) => {
       this._tree = Tree.from(treelike);
-      if (this._parent) {
+      if (this._parentUntilLoaded) {
+        // Now that the tree has been loaded, we can set its parent.
         if (!this._tree.parent) {
-          this._tree.parent = this._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._parent = null;
+        this._scopeUntilLoaded = null;
       }
       return this._tree;
     });

package/src/FileTree.js

@@ -1,15 +1,14 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 import {
   getRealmObjectPrototype,
   hiddenFileNames,
+  isPacked,
   sortNatural,
 } from "./utilities.js";
 
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-
 /**
  * A file system tree via the Node file system API.
  *
@@ -133,27 +132,29 @@ export default class FileTree {
       value = await value();
     }
 
+    let packed = false;
     if (value === null) {
       // Treat null value as empty string; will create an empty file.
       value = "";
-    } else if (value instanceof ArrayBuffer) {
-      // Convert ArrayBuffer to Uint8Array, which Node.js can write directly.
-      value = new Uint8Array(value);
-    }
-
-    // True if fs.writeFile can directly write the value to a file.
-    let isWriteable =
-      value instanceof TypedArray ||
-      value instanceof DataView ||
-      (globalThis.ReadableStream && value instanceof ReadableStream);
-
-    if (!isWriteable && isStringLike(value)) {
+      packed = true;
+    } else if (isPacked(value)) {
+      packed = true;
+    } else if (typeof value.pack === "function") {
+      // Pack the value for writing.
+      value = await value.pack();
+      packed = true;
+    } else if (isStringLike(value)) {
       // Value has a meaningful `toString` method, use that.
       value = String(value);
-      isWriteable = true;
+      packed = true;
     }
 
-    if (isWriteable) {
+    if (packed) {
+      // Single writeable value.
+      if (value instanceof ArrayBuffer) {
+        // Convert ArrayBuffer to Uint8Array, which Node.js can write directly.
+        value = new Uint8Array(value);
+      }
       // Ensure this directory exists.
       await fs.mkdir(this.dirname, { recursive: true });
       // Write out the value as the contents of a file.

package/src/FunctionTree.js

@@ -41,8 +41,4 @@ export default class FunctionTree {
   async keys() {
     return this.domain;
   }
-
-  async unpack() {
-    return this.fn;
-  }
 }

package/src/MapTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 
 /**
  * A tree backed by a JavaScript `Map` object.

package/src/ObjectTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 import { getRealmObjectPrototype } from "./utilities.js";
 
 /**

package/src/SetTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 
 /**
  * A tree of Set objects.

package/src/SiteTree.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 import * as keysJson from "./keysJson.js";
 
 /**
@@ -152,11 +152,6 @@ export default class SiteTree {
     return Reflect.construct(this.constructor, [href]);
   }
 
-  async unpack() {
-    const response = await fetch(this.href);
-    return response.ok ? response.arrayBuffer() : undefined;
-  }
-
   get url() {
     return new URL(this.href);
   }

package/src/Tree.d.ts

@@ -10,6 +10,7 @@ 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 isKeyForSubtree(tree: AsyncTree, obj: any): Promise<boolean>;
+export function isTraversable(obj: any): boolean;
 export function isTreelike(obj: any): obj is Treelike;
 export function map(tree: Treelike, valueFn: ValueKeyFn): AsyncTree;
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn|null, reduceFn: ReduceFn): Promise<any>;

package/src/Tree.js

@@ -1,11 +1,16 @@
 import DeferredTree from "./DeferredTree.js";
 import FunctionTree from "./FunctionTree.js";
 import MapTree from "./MapTree.js";
-import ObjectTree from "./ObjectTree.js";
 import SetTree from "./SetTree.js";
+import { DeepObjectTree, ObjectTree } from "./internal.js";
 import mapTransform from "./transforms/map.js";
 import * as utilities from "./utilities.js";
-import { castArrayLike, isPlainObject } from "./utilities.js";
+import {
+  castArrayLike,
+  isPacked,
+  isPlainObject,
+  isUnpackable,
+} from "./utilities.js";
 
 /**
  * Helper functions for working with async trees
@@ -112,7 +117,9 @@ export function from(obj) {
     return new MapTree(obj);
   } else if (obj instanceof Set) {
     return new SetTree(obj);
-  } else if (obj && typeof obj === "object" && "unpack" in obj) {
+  } else if (isPlainObject(obj)) {
+    return new DeepObjectTree(obj);
+  } else if (isUnpackable(obj)) {
     async function AsyncFunction() {} // Sample async function
     return obj.unpack instanceof AsyncFunction.constructor
       ? // Async unpack: return a deferred tree.
@@ -163,23 +170,52 @@ export function isAsyncMutableTree(object) {
   return isAsyncTree(object) && typeof object.set === "function";
 }
 
+/**
+ * Return true if the indicated key produces or is expected to produce an
+ * async tree.
+ *
+ * This defers to the tree's own isKeyForSubtree method. If not found, this
+ * gets the value of that key and returns true if the value is an async
+ * tree.
+ */
+export async function isKeyForSubtree(tree, key) {
+  if (tree.isKeyForSubtree) {
+    return tree.isKeyForSubtree(key);
+  }
+  const value = await tree.get(key);
+  return isAsyncTree(value);
+}
+
+/**
+ * Return true if the object can be traversed via the `traverse()` method. The
+ * object must be either treelike or a packed object with an `unpack()` method.
+ *
+ * @param {any} object
+ */
+export function isTraversable(object) {
+  return (
+    isTreelike(object) ||
+    (isPacked(object) && /** @type {any} */ (object).unpack instanceof Function)
+  );
+}
+
 /**
  * Returns true if the indicated object can be directly treated as an
  * asynchronous tree. This includes:
  *
  * - An object that implements the AsyncTree interface (including
  *   AsyncTree instances)
- * - An object that implements the `unpack()` method
  * - A function
  * - An `Array` instance
  * - A `Map` instance
  * - A `Set` instance
  * - A plain object
  *
- * Note: the `from()` method accepts any JavaScript object, but `isTreeable`
+ * Note: the `from()` method accepts any JavaScript object, but `isTreelike`
  * returns `false` for an object that isn't one of the above types.
  *
  * @param {any} object
+ * @returns {obj is Treelike}
  */
 export function isTreelike(object) {
   return (
@@ -187,27 +223,10 @@ export function isTreelike(object) {
     object instanceof Function ||
     object instanceof Array ||
     object instanceof Set ||
-    object?.unpack instanceof Function ||
     isPlainObject(object)
   );
 }
 
-/**
- * Return true if the indicated key produces or is expected to produce an
- * async tree.
- *
- * This defers to the tree's own isKeyForSubtree method. If not found, this
- * gets the value of that key and returns true if the value is an async
- * tree.
- */
-export async function isKeyForSubtree(tree, key) {
-  if (tree.isKeyForSubtree) {
-    return tree.isKeyForSubtree(key);
-  }
-  const value = await tree.get(key);
-  return isAsyncTree(value);
-}
-
 /**
  * Return a new tree with deeply-mapped values of the original tree.
  *
@@ -364,24 +383,16 @@ export async function traverseOrThrow(treelike, ...keys) {
       throw new TraverseError(message, treelike, keys);
     }
 
-    // Special case: one key left that's an empty string
-    if (remainingKeys.length === 1 && remainingKeys[0] === "") {
-      // Unpack the value if it defines an `unpack` function, otherwise return
-      // the value itself.
-      return typeof value.unpack === "function" ? await value.unpack() : value;
-    }
-
-    // If the value is not a function or async tree already, but can be
-    // unpacked, unpack it.
-    if (
-      !(value instanceof Function) &&
-      !isAsyncTree(value) &&
-      value.unpack instanceof Function
-    ) {
+    // If the value is packed and can be unpacked, unpack it.
+    if (isUnpackable(value)) {
       value = await value.unpack();
     }
 
-    if (value instanceof Function) {
+    // Peek ahead: if there's only one key left and it's an empty string, return
+    // the value itself.
+    if (remainingKeys.length === 1 && remainingKeys[0] === "") {
+      return value;
+    } else if (value instanceof Function) {
       // Value is a function: call it with the remaining keys.
       const fn = value;
       // We'll take as many keys as the function's length, but at least one.

package/src/internal.js

@@ -0,0 +1,15 @@
+//
+// This library includes a number of modules with circular dependencies. This
+// module exists to explicitly set the loading order for those modules. To
+// enforce use of this loading order, other modules should only load the modules
+// below via this module.
+//
+// About this pattern:
+// https://medium.com/visual-development/how-to-fix-nasty-circular-dependency-issues-once-and-for-all-in-javascript-typescript-a04c987cf0de
+//
+
+export * as Tree from "./Tree.js";
+
+export { default as ObjectTree } from "./ObjectTree.js";
+
+export { default as DeepObjectTree } from "./DeepObjectTree.js";

package/src/keysJson.js

@@ -1,4 +1,4 @@
-import * as Tree from "./Tree.js";
+import { Tree } from "./internal.js";
 
 /**
  * The .keys.json file format lets a site expose the keys of a node in the site

package/src/operations/cache.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { DeepObjectTree, Tree } from "../internal.js";
 
 /**
  * Caches values from a source tree in a second cache tree. If no second tree is
@@ -21,7 +21,7 @@ export default function treeCache(sourceTreelike, cacheTree, filterTreelike) {
   const filter = filterTreelike ? Tree.from(filterTreelike) : undefined;
 
   /** @type {AsyncMutableTree} */
-  const cache = cacheTree ?? new ObjectTree({});
+  const cache = cacheTree ?? new DeepObjectTree({});
   return {
     description: "cache",
 

package/src/operations/mergeDeep.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 /**
  * Return a tree that performs a deep merge of the given trees.

package/src/symbols.js

@@ -0,0 +1 @@
+export const parent = Symbol("parent");

package/src/transforms/cachedKeyFunctions.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 const treeToCaches = new WeakMap();
 

package/src/transforms/groupBy.js

@@ -1,5 +1,4 @@
-import ObjectTree from "../ObjectTree.js";
-import * as Tree from "../Tree.js";
+import { DeepObjectTree, Tree } from "../internal.js";
 
 /**
  * Given a function that returns a grouping key for a value, returns a transform
@@ -37,6 +36,6 @@ export default function createGroupByTransform(groupKeyFn) {
       }
     }
 
-    return new ObjectTree(result);
+    return new DeepObjectTree(result);
   };
 }

package/src/transforms/map.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 /**
  * Return a transform function that maps the keys and/or values of a tree.

package/src/transforms/regExpKeys.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 /**
  * A tree whose keys are strings interpreted as regular expressions.

package/src/transforms/sort.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 /**
  * Return a transform function that sorts a tree's keys.

package/src/transforms/sortBy.js

@@ -1,4 +1,4 @@
-import * as Tree from "../Tree.js";
+import { Tree } from "../internal.js";
 
 /**
  * Return a transform function that sorts a tree's keys.

package/src/utilities.d.ts

@@ -1,9 +1,11 @@
-import { PlainObject, StringLike } from "../index.ts";
+import { Packed, PlainObject, StringLike } from "../index.ts";
 
 export function castArrayLike(object: any): any;
 export function getRealmObjectPrototype(object: any): any;
 export const hiddenFileNames: string[];
+export function isPacked(object: any): object is Packed;
 export function isPlainObject(object: any): object is PlainObject;
+export function isUnpackable(object): object is { unpack: () => any };
 export function isStringLike(obj: any): obj is StringLike;
 export function keysFromPath(path: string): string[];
 export const naturalSortCompareFn: (a: string, b: string) => number;

package/src/utilities.js

@@ -1,3 +1,5 @@
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+
 /**
  * If the given plain object has only sequential integer keys, return it as an
  * array. Otherwise return it as is.
@@ -19,9 +21,6 @@ export function castArrayLike(object) {
   return hasKeys ? Object.values(object) : object;
 }
 
-// Names of OS-generated files that should not be enumerated
-export const hiddenFileNames = [".DS_Store"];
-
 /**
  * Return the Object prototype at the root of the object's prototype chain.
  *
@@ -38,6 +37,27 @@ export function getRealmObjectPrototype(object) {
   return proto;
 }
 
+// Names of OS-generated files that should not be enumerated
+export const hiddenFileNames = [".DS_Store"];
+
+/**
+ * Return true if the object is in a packed form (or can be readily packed into
+ * a form) that can be given to fs.writeFile or response.write().
+ *
+ * @param {any} object
+ * @returns {object is import("../index.ts").Packed}
+ */
+export function isPacked(object) {
+  return (
+    typeof object === "string" ||
+    object instanceof ArrayBuffer ||
+    object instanceof Buffer ||
+    object instanceof ReadableStream ||
+    object instanceof String ||
+    object instanceof TypedArray
+  );
+}
+
 /**
  * Return true if the object is a plain JavaScript object created by `{}`,
  * `new Object()`, or `Object.create(null)`.
@@ -46,6 +66,7 @@ export function getRealmObjectPrototype(object) {
  * `Module`) as plain objects.
  *
  * @param {any} object
+ * @returns {object is import("../index.ts").PlainObject}
  */
 export function isPlainObject(object) {
   // From https://stackoverflow.com/q/51722354/76472
@@ -67,15 +88,15 @@ export function isPlainObject(object) {
  * Return true if the object is a string or object with a non-trival `toString`
  * method.
  *
- * @param {any} obj
- * @returns {obj is import("@weborigami/async-tree").StringLike}
+ * @param {any} object
+ * @returns {obj is import("../index.ts").StringLike}
  */
-export function isStringLike(obj) {
-  if (typeof obj === "string") {
+export function isStringLike(object) {
+  if (typeof object === "string") {
     return true;
-  } else if (obj?.toString === undefined) {
+  } else if (object?.toString === undefined) {
     return false;
-  } else if (obj.toString === getRealmObjectPrototype(obj).toString) {
+  } else if (object.toString === getRealmObjectPrototype(object).toString) {
     // The stupid Object.prototype.toString implementation always returns
     // "[object Object]", so if that's the only toString method the object has,
     // we return false.
@@ -85,6 +106,13 @@ export function isStringLike(obj) {
   }
 }
 
+export function isUnpackable(object) {
+  return (
+    isPacked(object) &&
+    typeof (/** @type {any} */ (object).unpack) === "function"
+  );
+}
+
 /**
  * Given a path like "/foo/bar/baz", return an array of keys like ["foo", "bar",
  * "baz"].

package/test/BrowserFileTree.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import BrowserFileTree from "../src/BrowserFileTree.js";
-import * as Tree from "../src/Tree.js";
+import { Tree } from "../src/internal.js";
 
 // Skip these tests if we're not in a browser.
 const isBrowser = typeof window !== "undefined";

package/test/DeepObjectTree.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../src/DeepObjectTree.js";
-import * as Tree from "../src/Tree.js";
+import { DeepObjectTree, Tree } from "../src/internal.js";
 
 describe("DeepObjectTree", () => {
   test("returns an ObjectTree for value that's a plain sub-object or sub-array", async () => {

package/test/DeferredTree.test.js

@@ -1,8 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import DeferredTree from "../src/DeferredTree.js";
-import ObjectTree from "../src/ObjectTree.js";
-import * as Tree from "../src/Tree.js";
+import { ObjectTree, Tree } from "../src/internal.js";
 
 describe("DeferredTree", () => {
   test("lazy-loads a treelike object", async () => {

package/test/FileTree.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
 import FileTree from "../src/FileTree.js";
-import * as Tree from "../src/Tree.js";
+import { Tree } from "../src/internal.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const tempDirectory = path.join(dirname, "fixtures/temp");

package/test/FunctionTree.test.js

@@ -18,12 +18,6 @@ describe("FunctionTree", async () => {
     assert.equal(alice, "Hello, **Alice**.");
   });
 
-  test("unpacking the tree returns the function itself", async () => {
-    const fn = () => true;
-    const fixture = new FunctionTree(fn);
-    assert.equal(await fixture.unpack(), fn);
-  });
-
   test("getting a value from function with multiple arguments curries the function", async () => {
     const fixture = new FunctionTree((a, b, c) => a + b + c);
     const fnA = await fixture.get(1);

package/test/ObjectTree.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../src/ObjectTree.js";
-import * as Tree from "../src/Tree.js";
+import { ObjectTree, Tree } from "../src/internal.js";
 
 describe("ObjectTree", () => {
   test("can get the keys of the tree", async () => {

package/test/SetTree.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../src/ObjectTree.js";
 import SetTree from "../src/SetTree.js";
+import { ObjectTree } from "../src/internal.js";
 
 describe("SetTree", () => {
   test("can get the keys of the tree", async () => {

package/test/SiteTree.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
 import SiteTree from "../src/SiteTree.js";
-import * as Tree from "../src/Tree.js";
+import { Tree } from "../src/internal.js";
 
 const mockHost = "https://mock";
 

package/test/Tree.test.js

@@ -1,9 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree } from "../main.js";
 import MapTree from "../src/MapTree.js";
-import ObjectTree from "../src/ObjectTree.js";
-import * as Tree from "../src/Tree.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../src/internal.js";
 
 describe("Tree", () => {
   test("assign applies one tree to another", async () => {
@@ -89,13 +87,10 @@ describe("Tree", () => {
   });
 
   test("from() uses an object's unpack() method if defined", async () => {
-    const obj = {
-      unpack() {
-        return {
-          a: "Hello, a.",
-        };
-      },
-    };
+    const obj = new String();
+    /** @type {any} */ (obj).unpack = () => ({
+      a: "Hello, a.",
+    });
     const tree = Tree.from(obj);
     assert.deepEqual(await Tree.plain(tree), {
       a: "Hello, a.",
@@ -103,13 +98,10 @@ describe("Tree", () => {
   });
 
   test("from() creates a deferred tree if unpack() returns a promise", async () => {
-    const obj = {
-      async unpack() {
-        return {
-          a: "Hello, a.",
-        };
-      },
-    };
+    const obj = new String();
+    /** @type {any} */ (obj).unpack = async () => ({
+      a: "Hello, a.",
+    });
     const tree = Tree.from(obj);
     assert.deepEqual(await Tree.plain(tree), {
       a: "Hello, a.",
@@ -299,12 +291,10 @@ describe("Tree", () => {
   });
 
   test("traversing a final empty string can unpack the last value", async () => {
+    const unpackable = new String();
+    /** @type {any} */ (unpackable).unpack = () => "Content";
     const tree = {
-      unpackable: {
-        unpack() {
-          return "Content";
-        },
-      },
+      unpackable,
     };
     const result = await Tree.traverse(tree, "unpackable", "");
     assert.equal(result, "Content");

package/test/operations/cache.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/ObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { ObjectTree, Tree } from "../../src/internal.js";
 import cache from "../../src/operations/cache.js";
 
 describe("cache", () => {

package/test/operations/merge.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import merge from "../../src/operations/merge.js";
 
 describe("merge", () => {

package/test/operations/mergeDeep.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../../src/DeepObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
 import mergeDeep from "../../src/operations/mergeDeep.js";
 
 describe("mergeDeep", () => {

package/test/transforms/cachedKeyMaps.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/ObjectTree.js";
+import { ObjectTree } from "../../src/internal.js";
 import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
 
 describe("cachedKeyFunctions", () => {

package/test/transforms/groupBy.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import groupBy from "../../src/transforms/groupBy.js";
 
 describe("groupBy transform", () => {

package/test/transforms/keyMapsForExtensions.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/ObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { ObjectTree, Tree } from "../../src/internal.js";
 import keyFunctionsForExtensions from "../../src/transforms/keyFunctionsForExtensions.js";
 import map from "../../src/transforms/map.js";
 

package/test/transforms/map.test.js

@@ -1,9 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree } from "../../main.js";
-import DeepObjectTree from "../../src/DeepObjectTree.js";
 import FunctionTree from "../../src/FunctionTree.js";
-import * as Tree from "../../src/Tree.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import map from "../../src/transforms/map.js";
 
 describe("map", () => {

package/test/transforms/regExpKeys.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../../src/DeepObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
 import regExpKeys from "../../src/transforms/regExpKeys.js";
 
 describe("regExpKeys", () => {

package/test/transforms/sort.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sort from "../../src/transforms/sort.js";
 
 describe("sort transform", () => {

package/test/transforms/sortBy.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sortBy from "../../src/transforms/sortBy.js";
 
 describe("sortBy transform", () => {

package/test/transforms/sortNatural.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sortNatural from "../../src/transforms/sortNatural.js";
 
 describe("sortNatural transform", () => {