@weborigami/async-tree 0.5.4 → 0.5.5

package/test/Tree.test.js

@@ -1,407 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import MapTree from "../src/drivers/MapTree.js";
-import { DeepObjectTree, ObjectTree, Tree } from "../src/internal.js";
-import * as symbols from "../src/symbols.js";
-
-describe("Tree", () => {
-  test("assign applies one tree to another", async () => {
-    const target = new DeepObjectTree({
-      a: 1,
-      b: 2,
-      more: {
-        d: 3,
-      },
-    });
-
-    const source = new DeepObjectTree({
-      a: 4, // Overwrite existing value
-      b: undefined, // Delete
-      c: 5, // Add
-      more: {
-        // Should leave existing `more` keys alone.
-        e: 6, // Add
-      },
-      // Add new subtree
-      extra: {
-        f: 7,
-      },
-    });
-
-    // Apply changes.
-    const result = await Tree.assign(target, source);
-
-    assert.equal(result, target);
-    const plain = await Tree.plain(target);
-    assert.deepEqual(plain, {
-      a: 4,
-      c: 5,
-      more: {
-        d: 3,
-        e: 6,
-      },
-      extra: {
-        f: 7,
-      },
-    });
-  });
-
-  test("assign() can apply updates to an array", async () => {
-    const target = new ObjectTree(["a", "b", "c"]);
-    await Tree.assign(target, ["d", "e"]);
-    assert.deepEqual(await Tree.plain(target), ["d", "e", "c"]);
-  });
-
-  test("clear() removes all values", async () => {
-    const fixture = createFixture();
-    await Tree.clear(fixture);
-    assert.deepEqual(Array.from(await Tree.entries(fixture)), []);
-  });
-
-  test("entries() returns the [key, value] pairs", async () => {
-    const fixture = createFixture();
-    assert.deepEqual(Array.from(await Tree.entries(fixture)), [
-      ["Alice.md", "Hello, **Alice**."],
-      ["Bob.md", "Hello, **Bob**."],
-      ["Carol.md", "Hello, **Carol**."],
-    ]);
-  });
-
-  test("forEach() invokes a callback for each entry", async () => {
-    const fixture = createFixture();
-    const results = {};
-    await Tree.forEach(fixture, async (value, key) => {
-      results[key] = value;
-    });
-    assert.deepEqual(results, {
-      "Alice.md": "Hello, **Alice**.",
-      "Bob.md": "Hello, **Bob**.",
-      "Carol.md": "Hello, **Carol**.",
-    });
-  });
-
-  test("from() returns an async tree as is", async () => {
-    const tree1 = new ObjectTree({
-      a: "Hello, a.",
-    });
-    const tree2 = Tree.from(tree1);
-    assert.equal(tree2, tree1);
-  });
-
-  test("from() uses an object's unpack() method if defined", async () => {
-    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.",
-    });
-  });
-
-  test("from returns a deep object tree if deep option is true", async () => {
-    const obj = {
-      sub: {
-        a: 1,
-      },
-    };
-    const tree = Tree.from(obj, { deep: true });
-    assert(tree instanceof DeepObjectTree);
-  });
-
-  test("from returns a deep object tree if object has [deep] symbol set", async () => {
-    const obj = {
-      sub: {
-        a: 1,
-      },
-    };
-    Object.defineProperty(obj, symbols.deep, { value: true });
-    const tree = Tree.from(obj);
-    assert(tree instanceof DeepObjectTree);
-  });
-
-  test("from() creates a deferred tree if unpack() returns a promise", async () => {
-    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.",
-    });
-  });
-
-  test("from() autoboxes primitive values", async () => {
-    const tree = Tree.from("Hello, world.");
-    const slice = await tree.get("slice");
-    const result = await slice(0, 5);
-    assert.equal(result, "Hello");
-  });
-
-  test("has returns true if the key exists", async () => {
-    const fixture = createFixture();
-    assert.equal(await Tree.has(fixture, "Alice.md"), true);
-    assert.equal(await Tree.has(fixture, "David.md"), false);
-  });
-
-  test("isAsyncTree returns true if the object is a tree", () => {
-    const missingGetAndKeys = {};
-    assert(!Tree.isAsyncTree(missingGetAndKeys));
-
-    const missingIterator = {
-      async get() {},
-    };
-    assert(!Tree.isAsyncTree(missingIterator));
-
-    const missingGet = {
-      async keys() {},
-    };
-    assert(!Tree.isAsyncTree(missingGet));
-
-    const hasGetAndKeys = {
-      async get() {},
-      async keys() {},
-    };
-    assert(Tree.isAsyncTree(hasGetAndKeys));
-  });
-
-  test("isAsyncMutableTree returns true if the object is a mutable tree", () => {
-    assert.equal(
-      Tree.isAsyncMutableTree({
-        get() {},
-        keys() {},
-      }),
-      false
-    );
-    assert.equal(Tree.isAsyncMutableTree(createFixture()), true);
-  });
-
-  test("isTreelike() returns true if the argument can be cast to an async tree", () => {
-    assert(!Tree.isTreelike(null));
-    assert(Tree.isTreelike({}));
-    assert(Tree.isTreelike([]));
-    assert(Tree.isTreelike(new Map()));
-    assert(Tree.isTreelike(new Set()));
-  });
-
-  test("map() maps values", async () => {
-    const tree = new DeepObjectTree({
-      a: "Alice",
-      more: {
-        b: "Bob",
-      },
-    });
-    const mapped = Tree.map(tree, {
-      deep: true,
-      value: (value) => value.toUpperCase(),
-    });
-    assert.deepEqual(await Tree.plain(mapped), {
-      a: "ALICE",
-      more: {
-        b: "BOB",
-      },
-    });
-  });
-
-  test("mapReduce() can map values and reduce them", async () => {
-    const tree = new DeepObjectTree({
-      a: 1,
-      b: 2,
-      more: {
-        c: 3,
-      },
-      d: 4,
-    });
-    const reduced = await Tree.mapReduce(
-      tree,
-      (value) => value,
-      async (values) => String.prototype.concat(...values)
-    );
-    assert.deepEqual(reduced, "1234");
-  });
-
-  test("paths 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 Tree.paths(tree), ["a", "b", "c/d", "c/e"]);
-  });
-
-  test("paths 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 Tree.paths(tree, { assumeSlashes: true }), [
-      "a",
-      "b",
-      "c",
-      "d/e",
-    ]);
-  });
-
-  test("plain() 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,
-      },
-    });
-    const plain = await Tree.plain(tree);
-    assert.deepEqual(plain, {
-      a: 1,
-      sub1: {
-        b: 2,
-      },
-      sub2: {
-        c: 3,
-      },
-    });
-  });
-
-  test("plain() produces an array for an array-like tree", async () => {
-    const original = ["a", "b", "c"];
-    const tree = new ObjectTree(original);
-    const plain = await Tree.plain(tree);
-    assert.deepEqual(plain, original);
-  });
-
-  test("plain() 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);
-    const plain = await Tree.plain(tree);
-    assert.deepEqual(plain, original);
-  });
-
-  test("plain() returns empty array or object for ObjectTree as necessary", async () => {
-    const tree = new ObjectTree({});
-    assert.deepEqual(await Tree.plain(tree), {});
-    const arrayTree = new ObjectTree([]);
-    assert.deepEqual(await Tree.plain(arrayTree), []);
-  });
-
-  test("plain() awaits async properties", async () => {
-    const object = {
-      get name() {
-        return Promise.resolve("Alice");
-      },
-    };
-    assert.deepEqual(await Tree.plain(object), { name: "Alice" });
-  });
-
-  test("plain() coerces TypedArray values to strings", async () => {
-    const tree = new ObjectTree({
-      a: new TextEncoder().encode("Hello, world."),
-    });
-    const plain = await Tree.plain(tree);
-    assert.equal(plain.a, "Hello, world.");
-  });
-
-  test("remove method removes a value", async () => {
-    const fixture = createFixture();
-    await Tree.remove(fixture, "Alice.md");
-    assert.deepEqual(Array.from(await Tree.entries(fixture)), [
-      ["Bob.md", "Hello, **Bob**."],
-      ["Carol.md", "Hello, **Carol**."],
-    ]);
-  });
-
-  test("toFunction returns a function that invokes a tree's get() method", async () => {
-    const tree = new ObjectTree({
-      a: 1,
-      b: 2,
-    });
-    const fn = Tree.toFunction(tree);
-    assert.equal(await fn("a"), 1);
-    assert.equal(await fn("b"), 2);
-  });
-
-  test("traverse() a path of keys", async () => {
-    const tree = new ObjectTree({
-      a1: 1,
-      a2: {
-        b1: 2,
-        b2: {
-          c1: 3,
-          c2: 4,
-        },
-      },
-    });
-    assert.equal(await Tree.traverse(tree), tree);
-    assert.equal(await Tree.traverse(tree, "a1"), 1);
-    assert.equal(await Tree.traverse(tree, "a2", "b2", "c2"), 4);
-    assert.equal(
-      await Tree.traverse(tree, "a2", "doesntexist", "c2"),
-      undefined
-    );
-  });
-
-  test("traverse() a function with fixed number of arguments", async () => {
-    const tree = (a, b) => ({
-      c: "Result",
-    });
-    assert.equal(await Tree.traverse(tree, "a", "b", "c"), "Result");
-  });
-
-  test("traverse() from one tree into another", async () => {
-    const tree = new ObjectTree({
-      a: {
-        b: new MapTree([
-          ["c", "Hello"],
-          ["d", "Goodbye"],
-        ]),
-      },
-    });
-    assert.equal(await Tree.traverse(tree, "a", "b", "c"), "Hello");
-  });
-
-  test("traversePath() traverses a slash-separated path", async () => {
-    const tree = new ObjectTree({
-      a: {
-        b: {
-          c: "Hello",
-        },
-      },
-    });
-    assert.equal(await Tree.traversePath(tree, "a/b/c"), "Hello");
-  });
-
-  test("values() returns the store's values", async () => {
-    const fixture = createFixture();
-    assert.deepEqual(Array.from(await Tree.values(fixture)), [
-      "Hello, **Alice**.",
-      "Hello, **Bob**.",
-      "Hello, **Carol**.",
-    ]);
-  });
-});
-
-function createFixture() {
-  return new ObjectTree({
-    "Alice.md": "Hello, **Alice**.",
-    "Bob.md": "Hello, **Bob**.",
-    "Carol.md": "Hello, **Carol**.",
-  });
-}

package/test/utilities.test.js

@@ -1,141 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { ObjectTree } from "../src/internal.js";
-import * as symbols from "../src/symbols.js";
-import * as utilities from "../src/utilities.js";
-
-describe("utilities", () => {
-  test("box returns a boxed value", () => {
-    const string = "string";
-    const stringObject = utilities.box(string);
-    assert(stringObject instanceof String);
-    assert.equal(stringObject, string);
-
-    const number = 1;
-    const numberObject = utilities.box(number);
-    assert(numberObject instanceof Number);
-    assert.equal(numberObject, number);
-
-    const boolean = true;
-    const booleanObject = utilities.box(boolean);
-    assert(booleanObject instanceof Boolean);
-    assert.equal(booleanObject, boolean);
-
-    const object = {};
-    const boxedObject = utilities.box(object);
-    assert.equal(boxedObject, object);
-  });
-
-  test("getRealmObjectPrototype returns the object's root prototype", () => {
-    const object = {};
-    const proto = utilities.getRealmObjectPrototype(object);
-    assert.equal(proto, Object.prototype);
-  });
-
-  test("isPlainObject returns true if the object is a plain object", () => {
-    assert.equal(utilities.isPlainObject({}), true);
-    assert.equal(utilities.isPlainObject(new Object()), true);
-    assert.equal(utilities.isPlainObject(Object.create(null)), true);
-    class Foo {}
-    assert.equal(utilities.isPlainObject(new Foo()), false);
-  });
-
-  test("keysFromPath() returns the keys from a slash-separated path", () => {
-    assert.deepEqual(utilities.keysFromPath(""), []);
-    assert.deepEqual(utilities.keysFromPath("/"), []);
-    assert.deepEqual(utilities.keysFromPath("a/b/c"), ["a/", "b/", "c"]);
-    assert.deepEqual(utilities.keysFromPath("a/b/c/"), ["a/", "b/", "c/"]);
-    assert.deepEqual(utilities.keysFromPath("/foo/"), ["foo/"]);
-    assert.deepEqual(utilities.keysFromPath("a///b"), ["a/", "b"]);
-  });
-
-  test("naturalOrder compares strings in natural order", () => {
-    const strings = ["file10", "file1", "file9"];
-    strings.sort(utilities.naturalOrder);
-    assert.deepEqual(strings, ["file1", "file9", "file10"]);
-  });
-
-  test("pathFromKeys() returns a slash-separated path from keys", () => {
-    assert.equal(utilities.pathFromKeys([]), "");
-    assert.equal(utilities.pathFromKeys(["a", "b", "c"]), "a/b/c");
-    assert.equal(utilities.pathFromKeys(["a/", "b/", "c"]), "a/b/c");
-    assert.equal(utilities.pathFromKeys(["a/", "b/", "c/"]), "a/b/c/");
-  });
-
-  test("pipeline applies a series of functions to a value", async () => {
-    const addOne = (n) => n + 1;
-    const double = (n) => n * 2;
-    const square = (n) => n * n;
-    const result = await utilities.pipeline(1, addOne, double, square);
-    assert.equal(result, 16);
-  });
-
-  test("setParent sets a child's parent", () => {
-    const parent = new ObjectTree({});
-
-    // Set [symbols.parent] on a plain object.
-    const object = {};
-    utilities.setParent(object, parent);
-    assert.equal(object[symbols.parent], parent);
-
-    // Leave [symbols.parent] alone if it's already set.
-    const childWithParent = {
-      [symbols.parent]: "parent",
-    };
-    utilities.setParent(childWithParent, parent);
-    assert.equal(childWithParent[symbols.parent], "parent");
-
-    // Set `parent` on a tree.
-    const tree = new ObjectTree({});
-    utilities.setParent(tree, parent);
-    assert.equal(tree.parent, parent);
-
-    // Leave `parent` alone if it's already set.
-    const treeWithParent = new ObjectTree({});
-    treeWithParent.parent = "parent";
-    utilities.setParent(treeWithParent, parent);
-    assert.equal(treeWithParent.parent, "parent");
-  });
-
-  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",
-    };
-    assert.equal(utilities.toString(object), "text");
-  });
-
-  test("toString returns null for an object with no useful `toString`", () => {
-    const object = {};
-    assert.equal(utilities.toString(object), null);
-  });
-
-  test("toString decodes an ArrayBuffer as UTF-8", () => {
-    const arrayBuffer = new TextEncoder().encode("text").buffer;
-    assert.equal(utilities.toString(arrayBuffer), "text");
-  });
-});