@weborigami/async-tree 0.5.8 → 0.6.1

package/test/drivers/DeepObjectTree.test.js

@@ -1,35 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-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 () => {
-    const tree = createFixture();
-
-    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);
-  });
-
-  test("adds trailing slashes to keys for subtrees including plain objects or arrays", async () => {
-    const tree = createFixture();
-    const keys = Array.from(await tree.keys());
-    assert.deepEqual(keys, ["a", "object/", "array/"]);
-  });
-});
-
-function createFixture() {
-  return new DeepObjectTree({
-    a: 1,
-    object: {
-      b: 2,
-    },
-    array: [3],
-  });
-}

package/test/drivers/DeferredTree.test.js

@@ -1,22 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import DeferredTree from "../../src/drivers/DeferredTree.js";
-import { ObjectTree, Tree } from "../../src/internal.js";
-
-describe("DeferredTree", () => {
-  test("lazy-loads a treelike object", async () => {
-    const tree = new DeferredTree(async () => ({ a: 1, b: 2, c: 3 }));
-    assert.deepEqual(await Tree.plain(tree), { a: 1, b: 2, c: 3 });
-  });
-
-  test("sets parent on subtrees", async () => {
-    const object = {
-      a: 1,
-    };
-    const parent = new ObjectTree({});
-    const fixture = new DeferredTree(() => object);
-    fixture.parent = parent;
-    const tree = await fixture.tree();
-    assert.equal(tree.parent, parent);
-  });
-});

package/test/drivers/FileTree.test.js

@@ -1,192 +0,0 @@
-import assert from "node:assert";
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
-import FileTree from "../../src/drivers/FileTree.js";
-import { ObjectTree, 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("FileTree", async () => {
-  test("can get the keys of the tree", async () => {
-    const fixture = createFixture("fixtures/markdown");
-    assert.deepEqual(Array.from(await fixture.keys()), [
-      "Alice.md",
-      "Bob.md",
-      "Carol.md",
-      "subfolder/",
-    ]);
-  });
-
-  test("can get the value for a key", async () => {
-    const fixture = createFixture("fixtures/markdown");
-    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 () => {
-    const fixture = createFixture("fixtures/markdown");
-    assert.equal(await fixture.get("xyz"), undefined);
-  });
-
-  test("getting empty key returns undefined", async () => {
-    const fixture = createFixture("fixtures/markdown");
-    assert.equal(await fixture.get(""), undefined);
-  });
-
-  test("getting a null/undefined key throws an exception", async () => {
-    const fixture = createFixture("fixtures/markdown");
-    await assert.rejects(async () => {
-      await fixture.get(null);
-    });
-    await assert.rejects(async () => {
-      await fixture.get(undefined);
-    });
-  });
-
-  test("can retrieve values with optional trailing slash", async () => {
-    const fixture = createFixture("fixtures/markdown");
-    assert(await fixture.get("Alice.md"));
-    assert(await fixture.get("Alice.md/"));
-    assert(await fixture.get("subfolder"));
-    assert(await fixture.get("subfolder/"));
-  });
-
-  test("sets parent on subtrees", async () => {
-    const fixture = createFixture("fixtures");
-    const markdown = await fixture.get("markdown");
-    assert.equal(markdown.parent, fixture);
-  });
-
-  test("can write out a file via set()", async () => {
-    await createTempDirectory();
-
-    // Write out a file.
-    const fileName = "file1";
-    const fileText = "This is the first file.";
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set(fileName, fileText);
-
-    // Read it back in.
-    const filePath = path.join(tempDirectory, fileName);
-    const actualText = String(await fs.readFile(filePath));
-
-    assert.equal(fileText, actualText);
-
-    await removeTempDirectory();
-  });
-
-  test("create subfolder via set() with empty object value", async () => {
-    await createTempDirectory();
-
-    // Write out new, empty folder called "empty".
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set("empty", {});
-
-    // Verify folder exists and has no contents.
-    const folderPath = path.join(tempDirectory, "empty");
-    const stats = await fs.stat(folderPath);
-    assert(stats.isDirectory());
-    const files = await fs.readdir(folderPath);
-    assert.deepEqual(files, []);
-
-    await removeTempDirectory();
-  });
-
-  test("create subfolder via set() with empty tree value", async () => {
-    await createTempDirectory();
-
-    // Write out new, empty folder called "empty".
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set("empty", new ObjectTree({}));
-
-    // Verify folder exists and has no contents.
-    const folderPath = path.join(tempDirectory, "empty");
-    const stats = await fs.stat(folderPath);
-    assert(stats.isDirectory());
-    const files = await fs.readdir(folderPath);
-    assert.deepEqual(files, []);
-
-    await removeTempDirectory();
-  });
-
-  test("can write out subfolder via set()", async () => {
-    await createTempDirectory();
-
-    // Create a tiny set of "files".
-    const obj = {
-      file1: "This is the first file.",
-      subfolder: {
-        file2: "This is the second file.",
-      },
-    };
-
-    // Write out files as a new folder called "folder".
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set("folder", obj);
-
-    // Read them back in.
-    const actualFiles = await tempFiles.get("folder");
-    const strings = await Tree.map(actualFiles, {
-      deep: true,
-      value: (buffer) => textDecoder.decode(buffer),
-    });
-    const plain = await Tree.plain(strings);
-    assert.deepEqual(plain, obj);
-
-    await removeTempDirectory();
-  });
-
-  test("can delete a file via set()", async () => {
-    await createTempDirectory();
-    const tempFile = path.join(tempDirectory, "file");
-    await fs.writeFile(tempFile, "");
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set("file", undefined);
-    let stats;
-    try {
-      stats = await fs.stat(tempFile);
-    } catch (/** @type {any} */ error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    assert(stats === undefined);
-    await removeTempDirectory();
-  });
-
-  test("can delete a folder via set()", async () => {
-    await createTempDirectory();
-    const folder = path.join(tempDirectory, "folder");
-    await fs.mkdir(folder);
-    const tempFiles = new FileTree(tempDirectory);
-    await tempFiles.set("folder", undefined);
-    let stats;
-    try {
-      stats = await fs.stat(folder);
-    } catch (/** @type {any} */ error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    assert(stats === undefined);
-    await removeTempDirectory();
-  });
-});
-
-function createFixture(fixturePath) {
-  return new FileTree(path.join(dirname, fixturePath));
-}
-
-async function createTempDirectory() {
-  await fs.mkdir(tempDirectory, { recursive: true });
-}
-
-async function removeTempDirectory() {
-  await fs.rm(tempDirectory, { recursive: true });
-}

package/test/drivers/FunctionTree.test.js

@@ -1,46 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import FunctionTree from "../../src/drivers/FunctionTree.js";
-
-describe("FunctionTree", async () => {
-  test("can get the keys of the tree", async () => {
-    const fixture = createFixture();
-    assert.deepEqual(Array.from(await fixture.keys()), [
-      "Alice.md",
-      "Bob.md",
-      "Carol.md",
-    ]);
-  });
-
-  test("can get the value for a key", async () => {
-    const fixture = createFixture();
-    const alice = await fixture.get("Alice.md");
-    assert.equal(alice, "Hello, **Alice**.");
-  });
-
-  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);
-    const fnAB = await fnA.get(2);
-    const result = await fnAB.get(3);
-    assert.equal(result, 6);
-  });
-
-  test("getting an unsupported key returns undefined", async () => {
-    const fixture = createFixture();
-    assert.equal(await fixture.get("xyz"), undefined);
-  });
-});
-
-function createFixture() {
-  return new FunctionTree(
-    (key) => {
-      if (key?.endsWith?.(".md")) {
-        const name = key.slice(0, -3);
-        return `Hello, **${name}**.`;
-      }
-      return undefined;
-    },
-    ["Alice.md", "Bob.md", "Carol.md"]
-  );
-}

package/test/drivers/MapTree.test.js

@@ -1,59 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import MapTree from "../../src/drivers/MapTree.js";
-import * as symbols from "../../src/symbols.js";
-
-describe("MapTree", () => {
-  test("can get the keys of the tree", async () => {
-    const fixture = createFixture();
-    assert.deepEqual(Array.from(await fixture.keys()), ["a", "b", "c"]);
-  });
-
-  test("can get the value for a key", async () => {
-    const fixture = createFixture();
-    const a = await fixture.get("a");
-    assert.equal(a, 1);
-  });
-
-  test("sets parent on subtrees", async () => {
-    const map = new Map([["more", new Map([["a", 1]])]]);
-    const fixture = new MapTree(map);
-    const more = await fixture.get("more");
-    assert.equal(more[symbols.parent], fixture);
-  });
-
-  test("adds trailing slashes to keys for subtrees", async () => {
-    const tree = new MapTree([
-      ["a", 1],
-      ["subtree", new MapTree([["b", 2]])],
-    ]);
-    const keys = Array.from(await tree.keys());
-    assert.deepEqual(keys, ["a", "subtree/"]);
-  });
-
-  test("can retrieve values with optional trailing slash", async () => {
-    const subtree = new MapTree([["b", 2]]);
-    const tree = new MapTree([
-      ["a", 1],
-      ["subtree", subtree],
-    ]);
-    assert.equal(await tree.get("a"), 1);
-    assert.equal(await tree.get("a/"), 1);
-    assert.equal(await tree.get("subtree"), subtree);
-    assert.equal(await tree.get("subtree/"), subtree);
-  });
-
-  test("getting an unsupported key returns undefined", async () => {
-    const fixture = createFixture();
-    assert.equal(await fixture.get("d"), undefined);
-  });
-});
-
-function createFixture() {
-  const map = new Map([
-    ["a", 1],
-    ["b", 2],
-    ["c", 3],
-  ]);
-  return new MapTree(map);
-}

package/test/drivers/ObjectTree.test.js

@@ -1,163 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { ObjectTree, Tree } from "../../src/internal.js";
-import * as symbols from "../../src/symbols.js";
-
-describe("ObjectTree", () => {
-  test("can get the keys of the tree", async () => {
-    const fixture = createFixture();
-    assert.deepEqual(Array.from(await fixture.keys()), [
-      "Alice.md",
-      "Bob.md",
-      "Carol.md",
-    ]);
-  });
-
-  test("can get the value for a key", async () => {
-    const fixture = createFixture();
-    const alice = await fixture.get("Alice.md");
-    assert.equal(alice, "Hello, **Alice**.");
-  });
-
-  test("getting an unsupported key returns undefined", async () => {
-    const fixture = createFixture();
-    assert.equal(await fixture.get("xyz"), undefined);
-  });
-
-  test("getting a null/undefined key throws an exception", async () => {
-    const fixture = createFixture();
-    await assert.rejects(async () => {
-      await fixture.get(null);
-    });
-    await assert.rejects(async () => {
-      await fixture.get(undefined);
-    });
-  });
-
-  test("can set a value", async () => {
-    const tree = new ObjectTree({
-      a: 1,
-      b: 2,
-      c: 3,
-    });
-
-    // Update existing key
-    await tree.set("a", 4);
-
-    // Delete key
-    await tree.set("b", undefined);
-
-    // Overwrite key with trailing slash
-    await tree.set("c/", {});
-
-    // New key
-    await tree.set("d", 5);
-
-    assert.deepEqual(await Tree.entries(tree), [
-      ["a", 4],
-      ["c/", {}],
-      ["d", 5],
-    ]);
-  });
-
-  test("can wrap a class instance", async () => {
-    class Foo {
-      constructor() {
-        this.a = 1;
-      }
-
-      get prop() {
-        return this._prop;
-      }
-      set prop(prop) {
-        this._prop = prop;
-      }
-    }
-    class Bar extends Foo {
-      method() {}
-    }
-    const bar = new Bar();
-    /** @type {any} */ (bar).extra = "Hello";
-    const fixture = new ObjectTree(bar);
-    assert.deepEqual(await Tree.entries(fixture), [
-      ["a", 1],
-      ["extra", "Hello"],
-      ["prop", undefined],
-    ]);
-    assert.equal(await fixture.get("a"), 1);
-    await fixture.set("prop", "Goodbye");
-    assert.equal(bar.prop, "Goodbye");
-    assert.equal(await fixture.get("prop"), "Goodbye");
-  });
-
-  test("sets parent symbol on subobjects", async () => {
-    const fixture = new ObjectTree({
-      sub: {},
-    });
-    const sub = await fixture.get("sub");
-    assert.equal(sub[symbols.parent], fixture);
-  });
-
-  test("sets parent on subtrees", async () => {
-    const fixture = new ObjectTree({
-      a: 1,
-      more: new ObjectTree({
-        b: 2,
-      }),
-    });
-    const more = await fixture.get("more");
-    assert.equal(more.parent, fixture);
-  });
-
-  test("adds trailing slashes to keys for subtrees", async () => {
-    const tree = new ObjectTree({
-      a1: 1,
-      a2: new ObjectTree({
-        b1: 2,
-      }),
-      a3: 3,
-      a4: new ObjectTree({
-        b2: 4,
-      }),
-    });
-    const keys = Array.from(await tree.keys());
-    assert.deepEqual(keys, ["a1", "a2/", "a3", "a4/"]);
-  });
-
-  test("can retrieve values with optional trailing slash", async () => {
-    const subtree = {
-      async get(key) {},
-      async keys() {},
-    };
-    const tree = new ObjectTree({
-      a: 1,
-      subtree,
-    });
-    assert.equal(await tree.get("a"), 1);
-    assert.equal(await tree.get("a/"), 1);
-    assert.equal(await tree.get("subtree"), subtree);
-    assert.equal(await tree.get("subtree/"), subtree);
-  });
-
-  test("method on an object is bound to the object", async () => {
-    const n = new Number(123);
-    const tree = new ObjectTree(n);
-    const method = await tree.get("toString");
-    assert.equal(method(), "123");
-  });
-
-  test("defers to symbols.keys for keys if defined", async () => {
-    const tree = new ObjectTree({
-      [symbols.keys]: () => ["a", "b", "c"],
-    });
-    assert.deepEqual(Array.from(await tree.keys()), ["a", "b", "c"]);
-  });
-});
-
-function createFixture() {
-  return new ObjectTree({
-    "Alice.md": "Hello, **Alice**.",
-    "Bob.md": "Hello, **Bob**.",
-    "Carol.md": "Hello, **Carol**.",
-  });
-}

package/test/drivers/SetTree.test.js

@@ -1,44 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import SetTree from "../../src/drivers/SetTree.js";
-import { ObjectTree } from "../../src/internal.js";
-
-describe("SetTree", () => {
-  test("can get the keys of the tree", async () => {
-    const set = new Set(["a", "b", "c"]);
-    const fixture = new SetTree(set);
-    assert.deepEqual(Array.from(await fixture.keys()), [0, 1, 2]);
-  });
-
-  test("can get the value for a key", async () => {
-    const set = new Set(["a", "b", "c"]);
-    const fixture = new SetTree(set);
-    const a = await fixture.get(0);
-    assert.equal(a, "a");
-  });
-
-  test("getting an unsupported key returns undefined", async () => {
-    const set = new Set(["a", "b", "c"]);
-    const fixture = new SetTree(set);
-    assert.equal(await fixture.get(3), undefined);
-  });
-
-  test("getting a null/undefined key throws an exception", async () => {
-    const set = new Set(["a", "b", "c"]);
-    const fixture = new SetTree(set);
-    await assert.rejects(async () => {
-      await fixture.get(null);
-    });
-    await assert.rejects(async () => {
-      await fixture.get(undefined);
-    });
-  });
-
-  test("sets parent on subtrees", async () => {
-    const set = new Set();
-    set.add(new ObjectTree({}));
-    const fixture = new SetTree(set);
-    const subtree = await fixture.get(0);
-    assert.equal(subtree.parent, fixture);
-  });
-});

package/test/drivers/constantTree.test.js

@@ -1,13 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import constantTree from "../../src/drivers/constantTree.js";
-import { Tree } from "../../src/internal.js";
-
-describe("constantTree", () => {
-  test("returns a deep tree that returns constant for all keys", async () => {
-    const fixture = constantTree(1);
-    assert.equal(await fixture.get("a"), 1);
-    assert.equal(await fixture.get("b"), 1);
-    assert.equal(await Tree.traverse(fixture, "c/", "d/", "e"), 1);
-  });
-});

package/test/drivers/limitConcurrency.test.js

@@ -1,41 +0,0 @@
-import assert from "node:assert";
-import { before, describe, test } from "node:test";
-import limitConcurrency from "../../src/drivers/limitConcurrency.js";
-
-describe("limitConcurrency", async () => {
-  before(async () => {
-    // Confirm our limited functions throws on too many calls
-    const fn = createFixture();
-    try {
-      const array = Array.from({ length: 10 }, (_, index) => index);
-      await Promise.all(array.map((index) => fn(index)));
-    } catch (/** @type {any} */ error) {
-      assert.equal(error.message, "Too many calls");
-    }
-  });
-
-  test("limits the number of concurrent calls", async () => {
-    const fn = createFixture();
-    const limitedFn = limitConcurrency(fn, 3);
-    const array = Array.from({ length: 10 }, (_, index) => index);
-    const result = await Promise.all(array.map((index) => limitedFn(index)));
-    assert.deepEqual(result, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-});
-
-// Return a function that only permits a limited number of concurrent calls and
-// simulates a delay for each request.
-function createFixture() {
-  let activeCalls = 0;
-  const maxActiveCalls = 3;
-
-  return async function (n) {
-    if (activeCalls >= maxActiveCalls) {
-      throw new Error("Too many calls");
-    }
-    activeCalls++;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    activeCalls--;
-    return n;
-  };
-}

package/test/operations/isAsyncMutableTree.test.js

@@ -1,17 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import ObjectTree from "../../src/drivers/ObjectTree.js";
-import isAsyncMutableTree from "../../src/operations/isAsyncMutableTree.js";
-
-describe("isAsyncMutableTree", () => {
-  test("returns true if the object is a mutable tree", () => {
-    assert.equal(
-      isAsyncMutableTree({
-        get() {},
-        keys() {},
-      }),
-      false
-    );
-    assert.equal(isAsyncMutableTree(new ObjectTree({})), true);
-  });
-});

package/test/operations/isAsyncTree.test.js

@@ -1,26 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import isAsyncTree from "../../src/operations/isAsyncTree.js";
-
-describe("isAsyncTree", () => {
-  test("returns true if the object is a tree", () => {
-    const missingGetAndKeys = {};
-    assert(!isAsyncTree(missingGetAndKeys));
-
-    const missingIterator = {
-      async get() {},
-    };
-    assert(!isAsyncTree(missingIterator));
-
-    const missingGet = {
-      async keys() {},
-    };
-    assert(!isAsyncTree(missingGet));
-
-    const hasGetAndKeys = {
-      async get() {},
-      async keys() {},
-    };
-    assert(isAsyncTree(hasGetAndKeys));
-  });
-});

package/test/operations/isTreelike.test.js

@@ -1,13 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import isTreelike from "../../src/operations/isTreelike.js";
-
-describe("Fixture name goes here", () => {
-  test("isTreelike() returns true if the argument can be cast to an async tree", () => {
-    assert(!isTreelike(null));
-    assert(isTreelike({}));
-    assert(isTreelike([]));
-    assert(isTreelike(new Map()));
-    assert(isTreelike(new Set()));
-  });
-});