@weborigami/async-tree 0.5.8 → 0.6.0

package/test/operations/sort.test.js

@@ -1,17 +1,18 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import from from "../../src/operations/from.js";
+import keys from "../../src/operations/keys.js";
 import sort from "../../src/operations/sort.js";
 
 describe("sort", () => {
   test("sorts keys using default sort order", async () => {
-    const tree = Tree.from({
+    const tree = from({
       file10: null,
       file1: null,
       file9: null,
     });
     const sorted = await sort(tree);
-    assert.deepEqual(Array.from(await sorted.keys()), [
+    assert.deepEqual(Array.from(await keys(sorted)), [
       "file1",
       "file10",
       "file9",
@@ -19,7 +20,7 @@ describe("sort", () => {
   });
 
   test("invokes a comparison function", async () => {
-    const tree = Tree.from({
+    const tree = from({
       b: 2,
       c: 3,
       a: 1,
@@ -27,7 +28,7 @@ describe("sort", () => {
     // Reverse order
     const compare = (a, b) => (a > b ? -1 : a < b ? 1 : 0);
     const sorted = await sort(tree, { compare });
-    assert.deepEqual(Array.from(await sorted.keys()), ["c", "b", "a"]);
+    assert.deepEqual(Array.from(await keys(sorted)), ["c", "b", "a"]);
   });
 
   test("invokes a sortKey function", async () => {
@@ -39,10 +40,6 @@ describe("sort", () => {
     const sorted = await sort(tree, {
       sortKey: async (value, key, tree) => value.age,
     });
-    assert.deepEqual(Array.from(await sorted.keys()), [
-      "Bob",
-      "Carol",
-      "Alice",
-    ]);
+    assert.deepEqual(Array.from(await keys(sorted)), ["Bob", "Carol", "Alice"]);
   });
 });

package/test/operations/sync.test.js

@@ -0,0 +1,43 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import AsyncMap from "../../src/drivers/AsyncMap.js";
+import sync from "../../src/operations/sync.js";
+
+class SampleAsyncMap extends AsyncMap {
+  constructor(iterable) {
+    super();
+    this.map = new Map(iterable);
+  }
+
+  async get(key) {
+    return this.map.get(key);
+  }
+
+  async *keys() {
+    yield* this.map.keys();
+  }
+}
+
+describe("sync", () => {
+  test("converts an async tree to a sync tree", async () => {
+    const fixture = new SampleAsyncMap([
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        new SampleAsyncMap([
+          ["c", 3],
+          ["d", 4],
+        ]),
+      ],
+    ]);
+    const result = await sync(fixture);
+    assert(result instanceof Map);
+    assert.strictEqual(result.get("a"), 1);
+    assert.strictEqual(result.get("b"), 2);
+    const more = result.get("more");
+    assert(more instanceof Map);
+    assert.strictEqual(more.get("c"), 3);
+    assert.strictEqual(more.get("d"), 4);
+  });
+});

package/test/operations/take.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import plain from "../../src/operations/plain.js";
 import take from "../../src/operations/take.js";
 
 describe("take", () => {
@@ -12,7 +12,7 @@ describe("take", () => {
       d: 4,
     };
     const result = await take(tree, 2);
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await plain(result), {
       a: 1,
       b: 2,
     });

package/test/operations/toFunction.test.js

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
+import ObjectMap from "../../src/drivers/ObjectMap.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({
+    const tree = new ObjectMap({
       a: 1,
       b: 2,
     });

package/test/operations/traverse.test.js

@@ -1,12 +1,11 @@
 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 ObjectMap from "../../src/drivers/ObjectMap.js";
 import traverse from "../../src/operations/traverse.js";
 
 describe("traverse", () => {
   test("traverses a path of keys", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a1: 1,
       a2: {
         b1: 2,
@@ -30,9 +29,9 @@ describe("traverse", () => {
   });
 
   test("traverses from one tree into another", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: {
-        b: new MapTree([
+        b: new Map([
           ["c", "Hello"],
           ["d", "Goodbye"],
         ]),

package/test/operations/withKeys.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import plain from "../../src/operations/plain.js";
 import withKeys from "../../src/operations/withKeys.js";
 
 describe("withKeys", () => {
@@ -13,7 +13,7 @@ describe("withKeys", () => {
       },
       ["a", "c"]
     );
-    assert.deepEqual(await Tree.plain(result), {
+    assert.deepEqual(await plain(result), {
       a: 1,
       c: 3,
     });

package/test/utilities/setParent.test.js

@@ -1,12 +1,12 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
+import SyncMap from "../../src/drivers/SyncMap.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({});
+    const parent = new SyncMap();
 
     // Set [symbols.parent] on a plain object.
     const object = {};
@@ -21,14 +21,14 @@ describe("setParent", () => {
     assert.equal(childWithParent[symbols.parent], "parent");
 
     // Set `parent` on a tree.
-    const tree = new ObjectTree({});
+    const tree = new SyncMap();
     setParent(tree, parent);
     assert.equal(tree.parent, parent);
 
     // Leave `parent` alone if it's already set.
-    const treeWithParent = new ObjectTree({});
-    treeWithParent.parent = "parent";
+    const treeWithParent = new SyncMap();
+    treeWithParent.parent = parent;
     setParent(treeWithParent, parent);
-    assert.equal(treeWithParent.parent, "parent");
+    assert.equal(treeWithParent.parent, parent);
   });
 });

package/test/utilities/toFunction.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import toFunction from "../../src/utilities/toFunction.js";
 
 describe("toFunction", () => {
@@ -10,7 +10,7 @@ describe("toFunction", () => {
   });
 
   test("returns a tree's getter as a function", async () => {
-    const tree = new ObjectTree({
+    const tree = new ObjectMap({
       a: 1,
     });
     const fn = toFunction(tree);

package/test/utilities/toPlainValue.test.js

@@ -3,23 +3,62 @@ import { describe, test } from "node:test";
 import toPlainValue from "../../src/utilities/toPlainValue.js";
 
 describe("toPlainValue", () => {
-  test("returns the plainest representation of an object", async () => {
+  test("returns primitive value as is", async () => {
+    assert.equal(await toPlainValue(1), 1);
+    assert.equal(await toPlainValue("hello"), "hello");
+  });
+
+  test("invokes functions and resolves promises", async () => {
+    assert.equal(
+      await toPlainValue(() => "function result"),
+      "function result"
+    );
+    assert.equal(
+      await toPlainValue(Promise.resolve("promise result")),
+      "promise result"
+    );
+  });
+
+  test("plain object returned as is", async () => {
+    const obj = { a: 1, b: 2 };
+    assert.deepEqual(await toPlainValue(obj), obj);
+  });
+
+  test("resolves asynchronous object property", async () => {
+    const obj = {
+      get a() {
+        return Promise.resolve(1);
+      },
+      b: 2,
+    };
+    assert.deepEqual(await toPlainValue(obj), { a: 1, b: 2 });
+  });
+
+  test("converts maplike to plain object", async () => {
+    const map = new Map([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    assert.deepEqual(await toPlainValue(map), { a: 1, b: 2 });
+  });
+
+  test("ArrayBuffer with printable characters is returned as text", async () => {
+    const encoder = new TextEncoder();
+    const buffer = encoder.encode("printable text").buffer;
+    assert.equal(await toPlainValue(buffer), "printable text");
+  });
+
+  test("ArrayBuffer with non-printable characters is returned as base64", async () => {
+    const buffer = new Uint8Array([1, 2, 3]).buffer;
+    assert.equal(await toPlainValue(buffer), "AQID");
+  });
+
+  test("converts class instance to plain 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/src/drivers/DeepMapTree.js

@@ -1,23 +0,0 @@
-import isAsyncTree from "../operations/isAsyncTree.js";
-import MapTree from "./MapTree.js";
-
-export default class DeepMapTree extends MapTree {
-  async get(key) {
-    let value = await super.get(key);
-
-    if (value instanceof Map) {
-      value = Reflect.construct(this.constructor, [value]);
-    }
-
-    if (isAsyncTree(value) && !value.parent) {
-      value.parent = this;
-    }
-
-    return value;
-  }
-
-  /** @returns {boolean} */
-  isSubtree(value) {
-    return value instanceof Map || isAsyncTree(value);
-  }
-}

package/src/drivers/DeepObjectTree.js

@@ -1,18 +0,0 @@
-import isAsyncTree from "../operations/isAsyncTree.js";
-import isPlainObject from "../utilities/isPlainObject.js";
-import ObjectTree from "./ObjectTree.js";
-
-export default class DeepObjectTree extends ObjectTree {
-  async get(key) {
-    let value = await super.get(key);
-    if (value instanceof Array || isPlainObject(value)) {
-      value = Reflect.construct(this.constructor, [value]);
-    }
-    return value;
-  }
-
-  /** @returns {boolean} */
-  isSubtree(value) {
-    return value instanceof Array || isPlainObject(value) || isAsyncTree(value);
-  }
-}

package/src/drivers/DeferredTree.js

@@ -1,81 +0,0 @@
-import from from "../operations/from.js";
-
-/**
- * A tree that is loaded lazily.
- *
- * This is useful in situations that must return a tree synchronously. If
- * constructing the tree requires an asynchronous operation, this class can be
- * used as a wrapper that can be returned immediately. The tree will be loaded
- * the first time the keys() or get() functions are called.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class DeferredTree {
-  /**
-   * @param {Function|Promise<any>} loader
-   * @param {{ deep?: boolean }} [options]
-   */
-  constructor(loader, options) {
-    this.loader = loader;
-    this.treePromise = null;
-    this._tree = null;
-    this._parentUntilLoaded = null;
-    this._deep = options?.deep;
-  }
-
-  async get(key) {
-    const tree = await this.tree();
-    return tree.get(key);
-  }
-
-  async loadResult() {
-    if (!(this.loader instanceof Promise)) {
-      this.loader = this.loader();
-    }
-    return this.loader;
-  }
-
-  async keys() {
-    const tree = await this.tree();
-    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._parentUntilLoaded;
-  }
-  set parent(parent) {
-    if (this._tree && !this._tree.parent) {
-      this._tree.parent = parent;
-    } else {
-      this._parentUntilLoaded = parent;
-    }
-  }
-
-  async tree() {
-    if (this._tree) {
-      return this._tree;
-    }
-
-    // Use a promise to ensure the treelike is only converted to a tree once.
-    this.treePromise ??= this.loadResult().then((treelike) => {
-      const options =
-        this._deep !== undefined ? { deep: this._deep } : undefined;
-      this._tree = from(treelike, options);
-      if (this._parentUntilLoaded) {
-        // 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;
-      }
-      return this._tree;
-    });
-
-    return this.treePromise;
-  }
-}