@weborigami/async-tree 0.5.8 → 0.6.1

package/test/drivers/{ExplorableSiteTree.test.js → ExplorableSiteMap.test.js}

@@ -1,7 +1,9 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
-import ExplorableSiteTree from "../../src/drivers/ExplorableSiteTree.js";
-import { Tree } from "../../src/internal.js";
+import ExplorableSiteMap from "../../src/drivers/ExplorableSiteMap.js";
+import isMap from "../../src/operations/isMap.js";
+import map from "../../src/operations/map.js";
+import * as trailingSlash from "../../src/trailingSlash.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -34,31 +36,35 @@ const mockResponses = {
   },
 };
 
-describe("ExplorableSiteTree", () => {
+describe("ExplorableSiteMap", () => {
   beforeEach(() => {
     mock.method(global, "fetch", mockFetch);
   });
 
   test("can get the keys of a tree", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
-    const keys = await fixture.keys();
-    assert.deepEqual(Array.from(keys), ["about/", "index.html"]);
+    const fixture = new ExplorableSiteMap(mockHost);
+    const keys = [];
+    for await (const key of fixture.keys()) {
+      keys.push(key);
+    }
+    assert.deepEqual(keys, ["about/", "index.html"]);
   });
 
   test("can get a plain value for a key", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
+    const fixture = new ExplorableSiteMap(mockHost);
+    /** @type {any} */
     const arrayBuffer = await fixture.get("index.html");
     const text = textDecoder.decode(arrayBuffer);
     assert.equal(text, "Home page");
   });
 
   test("getting an unsupported key returns undefined", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
+    const fixture = new ExplorableSiteMap(mockHost);
     assert.equal(await fixture.get("xyz"), undefined);
   });
 
   test("getting a null/undefined key throws an exception", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
+    const fixture = new ExplorableSiteMap(mockHost);
     await assert.rejects(async () => {
       await fixture.get(null);
     });
@@ -68,20 +74,20 @@ describe("ExplorableSiteTree", () => {
   });
 
   test("can return a new tree for a key that redirects", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
+    const fixture = new ExplorableSiteMap(mockHost);
     const about = await fixture.get("about");
-    assert(about instanceof ExplorableSiteTree);
+    assert(about instanceof ExplorableSiteMap);
     assert.equal(about.href, "https://mock/about/");
   });
 
   test("can convert a site to a plain object", async () => {
-    const fixture = new ExplorableSiteTree(mockHost);
+    const fixture = new ExplorableSiteMap(mockHost);
     // Convert buffers to strings.
-    const strings = await Tree.map(fixture, {
+    const strings = await map(fixture, {
       deep: true,
       value: (value) => textDecoder.decode(value),
     });
-    assert.deepEqual(await Tree.plain(strings), {
+    assert.deepEqual(await plain(strings), {
       about: {
         "Alice.html": "Hello, Alice!",
         "Bob.html": "Hello, Bob!",
@@ -114,3 +120,12 @@ async function mockFetch(href) {
     status: 404,
   };
 }
+
+async function plain(tree) {
+  const result = {};
+  for await (const [key, value] of tree.entries()) {
+    const normalized = trailingSlash.remove(key);
+    result[normalized] = isMap(value) ? await plain(value) : value;
+  }
+  return result;
+}

package/test/drivers/FileMap.test.js

@@ -0,0 +1,156 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import path from "node:path";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import FileMap from "../../src/drivers/FileMap.js";
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const tempDirectory = path.join(dirname, "fixtures/temp");
+
+const textDecoder = new TextDecoder();
+
+describe("FileMap", () => {
+  test("can get the keys of the tree", () => {
+    const fixture = createFixture("fixtures/markdown");
+    assert.deepEqual(Array.from(fixture.keys()), [
+      "Alice.md",
+      "Bob.md",
+      "Carol.md",
+      "subfolder/",
+    ]);
+  });
+
+  test("can get the value for a key", () => {
+    const fixture = createFixture("fixtures/markdown");
+    const buffer = fixture.get("Alice.md");
+    const text = textDecoder.decode(buffer);
+    assert.equal(text, "Hello, **Alice**.");
+  });
+
+  test("getting an unsupported key returns undefined", () => {
+    const fixture = createFixture("fixtures/markdown");
+    assert.equal(fixture.get("xyz"), undefined);
+  });
+
+  test("getting empty key returns undefined", () => {
+    const fixture = createFixture("fixtures/markdown");
+    assert.equal(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", () => {
+    const fixture = createFixture("fixtures/markdown");
+    assert(fixture.get("Alice.md"));
+    assert(fixture.get("Alice.md/"));
+    assert(fixture.get("subfolder"));
+    assert(fixture.get("subfolder/"));
+  });
+
+  test("sets parent on subtrees", () => {
+    const fixture = createFixture("fixtures");
+    const markdown = fixture.get("markdown");
+    assert.deepEqual(markdown.parent, fixture);
+  });
+
+  test("can write out a file via set()", () => {
+    createTempDirectory();
+
+    // Write out a file.
+    const fileName = "file1";
+    const fileText = "This is the first file.";
+    const tempFiles = new FileMap(tempDirectory);
+    tempFiles.set(fileName, fileText);
+
+    // Read it back in.
+    const filePath = path.join(tempDirectory, fileName);
+    const actualText = String(fs.readFileSync(filePath));
+
+    assert.equal(fileText, actualText);
+
+    removeTempDirectory();
+  });
+
+  test("create subfolder via child()", () => {
+    createTempDirectory();
+
+    // Write out new, empty folder called "empty".
+    const tempFiles = new FileMap(tempDirectory);
+    tempFiles.child("empty");
+
+    // Verify folder exists and has no contents.
+    const folderPath = path.join(tempDirectory, "empty");
+    const stats = fs.statSync(folderPath);
+    assert(stats.isDirectory());
+    const files = fs.readdirSync(folderPath);
+    assert.deepEqual(files, []);
+
+    removeTempDirectory();
+  });
+
+  test("can delete a file", () => {
+    createTempDirectory();
+    const tempFile = path.join(tempDirectory, "file");
+    fs.writeFileSync(tempFile, "");
+    const tempFiles = new FileMap(tempDirectory);
+    const deleted = tempFiles.delete("file");
+    assert(deleted);
+    let stats;
+    try {
+      stats = fs.statSync(tempFile);
+    } catch (/** @type {any} */ error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    assert(stats === undefined);
+    removeTempDirectory();
+  });
+
+  test("delete returns false if file does not exist", () => {
+    createTempDirectory();
+    const tempFiles = new FileMap(tempDirectory);
+    const deleted = tempFiles.delete("nonexistent-file");
+    assert(!deleted);
+    removeTempDirectory();
+  });
+
+  test("can delete a folder", () => {
+    createTempDirectory();
+    const folder = path.join(tempDirectory, "folder");
+    fs.mkdirSync(folder);
+    const tempFiles = new FileMap(tempDirectory);
+    tempFiles.delete("folder");
+    let stats;
+    try {
+      stats = fs.statSync(folder);
+    } catch (/** @type {any} */ error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    assert(stats === undefined);
+    removeTempDirectory();
+  });
+});
+
+function createFixture(fixturePath) {
+  return new FileMap(path.join(dirname, fixturePath));
+}
+
+function createTempDirectory() {
+  fs.mkdirSync(tempDirectory, { recursive: true });
+}
+
+function removeTempDirectory() {
+  fs.rmSync(tempDirectory, { force: true, recursive: true });
+}

package/test/drivers/FunctionMap.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import FunctionMap from "../../src/drivers/FunctionMap.js";
+import * as symbols from "../../src/symbols.js";
+
+describe("FunctionMap", () => {
+  test("keys uses supplied domain", () => {
+    const map = createFixture();
+    assert.deepEqual(Array.from(map.keys()), [
+      "Alice.md",
+      "Bob.md",
+      "Carol.md",
+    ]);
+  });
+
+  test("can get the value for a key", () => {
+    const map = createFixture();
+    const alice = map.get("Alice.md");
+    assert.equal(alice, "Hello, **Alice**.");
+  });
+
+  test("can get the value for an async function", async () => {
+    const map = new FunctionMap(async (s) => ({ s }));
+    const result = await map.get("test");
+    assert.deepEqual(result, {
+      s: "test",
+    });
+    assert.equal(result[symbols.parent], map);
+  });
+
+  test("getting a value from function with multiple arguments curries the function", () => {
+    const map = new FunctionMap((a, b, c) => a + b + c);
+    const fnA = map.get(1);
+    const fnAB = fnA.get(2);
+    const result = fnAB.get(3);
+    assert.equal(result, 6);
+  });
+
+  test("getting an unsupported key returns undefined", () => {
+    const fixture = createFixture();
+    assert.equal(fixture.get("xyz"), undefined);
+  });
+});
+
+function createFixture() {
+  return new FunctionMap(
+    (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/ObjectMap.test.js

@@ -0,0 +1,194 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import plain from "../../src/operations/plain.js";
+import * as symbols from "../../src/symbols.js";
+
+describe("ObjectMap", () => {
+  test("can get the keys of the tree", () => {
+    const fixture = createFixture();
+    assert.deepEqual(Array.from(fixture.keys()), [
+      "Alice.md",
+      "Bob.md",
+      "Carol.md",
+    ]);
+  });
+
+  test("can get the value for a key", () => {
+    const map = createFixture();
+    const alice = map.get("Alice.md");
+    assert.equal(alice, "Hello, **Alice**.");
+  });
+
+  test("getting an unsupported key returns undefined", () => {
+    const map = createFixture();
+    assert.equal(map.get("xyz"), undefined);
+  });
+
+  test("getting a null/undefined key throws an exception", async () => {
+    const map = createFixture();
+    await assert.rejects(async () => {
+      map.get(null);
+    });
+    await assert.rejects(async () => {
+      map.get(undefined);
+    });
+  });
+
+  test("can set a value", () => {
+    const map = new ObjectMap({
+      a: 1,
+      b: 2,
+      c: 3,
+    });
+
+    // Update existing key
+    map.set("a", 4);
+
+    // Delete key
+    map.delete("b");
+
+    // Overwrite key with trailing slash
+    map.set("c/", {});
+
+    // New key
+    map.set("d", 5);
+
+    const entries = Array.from(map.entries());
+    assert.deepEqual(entries, [
+      ["a", 4],
+      ["c/", {}],
+      ["d", 5],
+    ]);
+  });
+
+  test("can wrap a class instance", () => {
+    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 map = new ObjectMap(bar);
+    const entries = Array.from(map.entries());
+    assert.deepEqual(entries, [
+      ["a", 1],
+      ["extra", "Hello"],
+      ["prop", undefined],
+    ]);
+    assert.equal(map.get("a"), 1);
+    map.set("prop", "Goodbye");
+    assert.equal(bar.prop, "Goodbye");
+    assert.equal(map.get("prop"), "Goodbye");
+  });
+
+  test("sets parent symbol on subobjects", () => {
+    const map = new ObjectMap({
+      sub: {},
+    });
+    const sub = map.get("sub");
+    assert.equal(sub[symbols.parent], map);
+  });
+
+  test("sets parent on subtrees", () => {
+    const map = new ObjectMap({
+      a: 1,
+      more: new ObjectMap({
+        b: 2,
+      }),
+    });
+    const more = map.get("more");
+    assert.equal(more.parent, map);
+  });
+
+  test("adds trailing slashes to keys for subtrees", () => {
+    const map = new ObjectMap({
+      a1: 1,
+      a2: new ObjectMap({
+        b1: 2,
+      }),
+      a3: 3,
+      a4: new ObjectMap({
+        b2: 4,
+      }),
+    });
+    const keys = Array.from(map.keys());
+    assert.deepEqual(keys, ["a1", "a2/", "a3", "a4/"]);
+  });
+
+  test("can retrieve values with optional trailing slash", () => {
+    const subMap = {
+      get(key) {},
+      keys() {},
+    };
+    const map = new ObjectMap({
+      a: 1,
+      subMap,
+    });
+    assert.equal(map.get("a"), 1);
+    assert.equal(map.get("a/"), 1);
+    assert.equal(map.get("subMap"), subMap);
+    assert.equal(map.get("subMap/"), subMap);
+  });
+
+  test("method on an object is bound to the object", () => {
+    const n = new Number(123);
+    const map = new ObjectMap(n);
+    const method = map.get("toString");
+    assert.equal(method(), "123");
+  });
+
+  test("defers to symbols.keys for keys if defined", () => {
+    const map = new ObjectMap({
+      [symbols.keys]: () => ["a", "b", "c"],
+    });
+    assert.deepEqual(Array.from(map.keys()), ["a", "b", "c"]);
+  });
+
+  test("deep option treats sub-objects and sub-arrays as child nodes", async () => {
+    const map = new ObjectMap(
+      {
+        a: 1,
+        object: {
+          b: 2,
+        },
+        array: [3],
+      },
+      { deep: true }
+    );
+
+    // Adds trailing slashes to keys for sub-objects and sub-arrays
+    const keys = Array.from(await map.keys());
+    assert.deepEqual(keys, ["a", "object/", "array/"]);
+
+    const object = await map.get("object");
+    assert.equal(object instanceof ObjectMap, true);
+    assert.deepEqual(await plain(object), { b: 2 });
+    assert.equal(object.parent, map);
+
+    const array = await map.get("array");
+    assert.equal(array instanceof ObjectMap, true);
+    assert.deepEqual(await plain(array), [3]);
+    assert.equal(array.parent, map);
+  });
+});
+
+function createFixture() {
+  return new ObjectMap({
+    "Alice.md": "Hello, **Alice**.",
+    "Bob.md": "Hello, **Bob**.",
+    "Carol.md": "Hello, **Carol**.",
+  });
+}

package/test/drivers/SetMap.test.js

@@ -0,0 +1,35 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import SetMap from "../../src/drivers/SetMap.js";
+
+describe("SetMap", () => {
+  test("can get the keys of the map", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    assert.deepEqual(Array.from(await fixture.keys()), ["a", "b", "c"]);
+  });
+
+  test("can get the value for a key", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    const a = await fixture.get("a");
+    assert.equal(a, "a");
+  });
+
+  test("getting an unsupported key returns undefined", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    assert.equal(await fixture.get("d"), undefined);
+  });
+
+  test("getting a null/undefined key throws an exception", async () => {
+    const set = new Set(["a", "b", "c"]);
+    const fixture = new SetMap(set);
+    await assert.rejects(async () => {
+      await fixture.get(null);
+    });
+    await assert.rejects(async () => {
+      await fixture.get(undefined);
+    });
+  });
+});

package/test/drivers/{SiteTree.test.js → SiteMap.test.js}

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
-import SiteTree from "../../src/drivers/SiteTree.js";
+import SiteMap from "../../src/drivers/SiteMap.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -27,38 +27,42 @@ const mockResponses = {
   },
 };
 
-describe("SiteTree", () => {
+describe("SiteMap", () => {
   beforeEach(() => {
     mock.method(global, "fetch", mockFetch);
   });
 
   test("returns an empty array as the keys of a tree", async () => {
-    const fixture = new SiteTree(mockHost);
-    const keys = await fixture.keys();
-    assert.deepEqual(Array.from(keys), []);
+    const fixture = new SiteMap(mockHost);
+    const keys = [];
+    for await (const key of fixture.keys()) {
+      keys.push(key);
+    }
+    assert.deepEqual(keys, []);
   });
 
   test("can get a plain value for a key", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
+    /** @type {any} */
     const arrayBuffer = await fixture.get("index.html");
     const text = textDecoder.decode(arrayBuffer);
     assert.equal(text, "Home page");
   });
 
   test("immediately return a new tree for a key with a trailing slash", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     const about = await fixture.get("about/");
-    assert(about instanceof SiteTree);
+    assert(about instanceof SiteMap);
     assert.equal(about.href, "https://mock/about/");
   });
 
   test("getting an unsupported key returns undefined", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     assert.equal(await fixture.get("xyz"), undefined);
   });
 
   test("getting a null/undefined key throws an exception", async () => {
-    const fixture = new SiteTree(mockHost);
+    const fixture = new SiteMap(mockHost);
     await assert.rejects(async () => {
       await fixture.get(null);
     });