@weborigami/async-tree 0.0.66-beta.1 → 0.0.66-beta.2

package/src/utilities.js

@@ -1,5 +1,6 @@
 import { Tree } from "./internal.js";
 import * as symbols from "./symbols.js";
+import * as trailingSlash from "./trailingSlash.js";
 
 const textDecoder = new TextDecoder();
 const TypedArray = Object.getPrototypeOf(Uint8Array);
@@ -155,20 +156,35 @@ export function isUnpackable(obj) {
 }
 
 /**
- * Given a path like "/foo/bar/baz", return an array of keys like ["foo", "bar",
- * "baz"].
+ * Given a path like "/foo/bar/baz", return an array of keys like ["foo/",
+ * "bar/", "baz"].
  *
- * Leading slashes are ignored. Consecutive slashes or a trailing slash will be
- * represented by the empty string.
+ * Leading slashes are ignored. Consecutive slashes will be ignored. Trailing
+ * slashes are preserved.
  *
  * @param {string} pathname
  */
 export function keysFromPath(pathname) {
-  const keys = pathname.split("/");
+  // Split the path at each slash
+  let keys = pathname.split("/");
   if (keys[0] === "") {
     // The path begins with a slash; drop that part.
     keys.shift();
   }
+  if (keys.at(-1) === "") {
+    // The path ends with a slash; drop that part.
+    keys.pop();
+  }
+  // Drop any empty keys
+  keys = keys.filter((key) => key !== "");
+  // Add the trailing slash back to all keys but the last
+  for (let i = 0; i < keys.length - 1; i++) {
+    keys[i] += "/";
+  }
+  // Add trailing slash to last key if path ended with a slash
+  if (keys.length > 0 && trailingSlash.has(pathname)) {
+    keys[keys.length - 1] += "/";
+  }
   return keys;
 }
 
@@ -283,7 +299,19 @@ export async function toPlainValue(input) {
 }
 
 function toBase64(object) {
-  return Buffer.from(object).toString("base64");
+  if (typeof Buffer !== "undefined") {
+    // Node.js environment
+    return Buffer.from(object).toString("base64");
+  } else {
+    // Browser environment
+    let binary = "";
+    const bytes = new Uint8Array(object);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
 }
 
 /**

package/test/BrowserFileTree.test.js

@@ -13,16 +13,14 @@ if (isBrowser) {
         "Alice.md",
         "Bob.md",
         "Carol.md",
+        "subfolder/",
       ]);
     });
 
     test("can get the value for a key", async () => {
       const fixture = await createFixture();
-      assert.deepEqual(await strings(fixture), {
-        "Alice.md": "Hello, **Alice**.",
-        "Bob.md": "Hello, **Bob**.",
-        "Carol.md": "Hello, **Carol**.",
-      });
+      const buffer = await fixture.get("Alice.md");
+      assert.equal(text(buffer), "Hello, **Alice**.");
     });
 
     test("getting an unsupported key returns undefined", async () => {
@@ -30,6 +28,11 @@ if (isBrowser) {
       assert.equal(await fixture.get("xyz"), undefined);
     });
 
+    test("getting empty key returns undefined", async () => {
+      const fixture = await createFixture();
+      assert.equal(await fixture.get(""), undefined);
+    });
+
     test("getting a null/undefined key throws an exception", async () => {
       const fixture = await createFixture();
       await assert.rejects(async () => {
@@ -40,6 +43,20 @@ if (isBrowser) {
       });
     });
 
+    test("sets parent on subtrees", async () => {
+      const fixture = await createFixture();
+      const subfolder = await fixture.get("subfolder");
+      assert.equal(subfolder.parent, fixture);
+    });
+
+    test("can retrieve values with optional trailing slash", async () => {
+      const fixture = await createFixture();
+      assert(await fixture.get("Alice.md"));
+      assert(await fixture.get("Alice.md/"));
+      assert(await fixture.get("subfolder"));
+      assert(await fixture.get("subfolder/"));
+    });
+
     test("can set a value", async () => {
       const fixture = await createFixture();
 
@@ -59,6 +76,7 @@ if (isBrowser) {
         "Alice.md": "Goodbye, **Alice**.",
         "Carol.md": "Hello, **Carol**.",
         "David.md": "Hello, **David**.",
+        subfolder: {},
       });
     });
 
@@ -81,6 +99,7 @@ if (isBrowser) {
         more: {
           "Ellen.md": "Hello, **Ellen**.",
         },
+        subfolder: {},
       });
     });
   });
@@ -118,6 +137,10 @@ async function createFixture() {
   await createFile(subdirectory, "Bob.md", "Hello, **Bob**.");
   await createFile(subdirectory, "Carol.md", "Hello, **Carol**.");
 
+  await subdirectory.getDirectoryHandle("subfolder", {
+    create: true,
+  });
+
   return new BrowserFileTree(subdirectory);
 }
 

package/test/DeepMapTree.test.js

@@ -0,0 +1,17 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import DeepMapTree from "../src/DeepMapTree.js";
+import { Tree } from "../src/internal.js";
+
+describe("DeepMapTree", () => {
+  test("returns a DeepMapTree for value that's a Map", async () => {
+    const tree = new DeepMapTree([
+      ["a", 1],
+      ["map", new Map([["b", 2]])],
+    ]);
+    const map = await tree.get("map");
+    assert.equal(map instanceof DeepMapTree, true);
+    assert.deepEqual(await Tree.plain(map), { b: 2 });
+    assert.equal(map.parent, tree);
+  });
+});

package/test/DeepObjectTree.test.js

@@ -4,13 +4,7 @@ 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 = new DeepObjectTree({
-      a: 1,
-      object: {
-        b: 2,
-      },
-      array: [3],
-    });
+    const tree = createFixture();
 
     const object = await tree.get("object");
     assert.equal(object instanceof DeepObjectTree, true);
@@ -22,4 +16,20 @@ describe("DeepObjectTree", () => {
     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/FileTree.test.js

@@ -18,6 +18,7 @@ describe("FileTree", async () => {
       "Alice.md",
       "Bob.md",
       "Carol.md",
+      "subfolder/",
     ]);
   });
 
@@ -33,6 +34,11 @@ describe("FileTree", async () => {
     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 () => {
@@ -43,17 +49,18 @@ describe("FileTree", async () => {
     });
   });
 
-  test("sets parent on subtrees", async () => {
-    const fixture = createFixture("fixtures");
-    const markdown = await fixture.get("markdown");
-    assert.equal(markdown.parent, fixture);
+  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("can indicate which values are subtrees", async () => {
+  test("sets parent on subtrees", async () => {
     const fixture = createFixture("fixtures");
-    assert(await fixture.isKeyForSubtree("markdown"));
     const markdown = await fixture.get("markdown");
-    assert(!(await markdown.isKeyForSubtree("a.txt")));
+    assert.equal(markdown.parent, fixture);
   });
 
   test("can write out a file via set()", async () => {

package/test/MapTree.test.js

@@ -22,6 +22,27 @@ describe("MapTree", () => {
     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);

package/test/ObjectTree.test.js

@@ -41,18 +41,21 @@ describe("ObjectTree", () => {
       c: 3,
     });
 
-    // Update existing key.
+    // Update existing key
     await tree.set("a", 4);
 
-    // New key.
-    await tree.set("d", 5);
-
-    // Delete key.
+    // 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", 3],
+      ["c/", {}],
       ["d", 5],
     ]);
   });
@@ -106,7 +109,7 @@ describe("ObjectTree", () => {
     assert.equal(more.parent, fixture);
   });
 
-  test("isKeyForSubtree() indicates which values are subtrees", async () => {
+  test("adds trailing slashes to keys for subtrees", async () => {
     const tree = new ObjectTree({
       a1: 1,
       a2: new ObjectTree({
@@ -118,21 +121,22 @@ describe("ObjectTree", () => {
       }),
     });
     const keys = Array.from(await tree.keys());
-    const subtrees = await Promise.all(
-      keys.map(async (key) => await tree.isKeyForSubtree(key))
-    );
-    assert.deepEqual(subtrees, [false, true, false, true]);
+    assert.deepEqual(keys, ["a1", "a2/", "a3", "a4/"]);
   });
 
-  test("returns an async tree value as is", async () => {
+  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 () => {

package/test/OpenSiteTree.test.js

@@ -0,0 +1,113 @@
+import assert from "node:assert";
+import { beforeEach, describe, mock, test } from "node:test";
+import OpenSiteTree from "../src/OpenSiteTree.js";
+import { Tree } from "../src/internal.js";
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+const mockHost = "https://mock";
+
+const mockResponses = {
+  "/.keys.json": {
+    data: JSON.stringify(["about/", "index.html"]),
+  },
+  "/about": {
+    redirected: true,
+    status: 301,
+    url: "https://mock/about/",
+  },
+  "/about/.keys.json": {
+    data: JSON.stringify(["Alice.html", "Bob.html", "Carol.html"]),
+  },
+  "/about/Alice.html": {
+    data: "Hello, Alice!",
+  },
+  "/about/Bob.html": {
+    data: "Hello, Bob!",
+  },
+  "/about/Carol.html": {
+    data: "Hello, Carol!",
+  },
+  "/index.html": {
+    data: "Home page",
+  },
+};
+
+describe("OpenSiteTree", () => {
+  beforeEach(() => {
+    mock.method(global, "fetch", mockFetch);
+  });
+
+  test("can get the keys of a tree", async () => {
+    const fixture = new OpenSiteTree(mockHost);
+    const keys = await fixture.keys();
+    assert.deepEqual(Array.from(keys), ["about/", "index.html"]);
+  });
+
+  test("can get a plain value for a key", async () => {
+    const fixture = new OpenSiteTree(mockHost);
+    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 OpenSiteTree(mockHost);
+    assert.equal(await fixture.get("xyz"), undefined);
+  });
+
+  test("getting a null/undefined key throws an exception", async () => {
+    const fixture = new OpenSiteTree(mockHost);
+    await assert.rejects(async () => {
+      await fixture.get(null);
+    });
+    await assert.rejects(async () => {
+      await fixture.get(undefined);
+    });
+  });
+
+  test("can return a new tree for a key that redirects", async () => {
+    const fixture = new OpenSiteTree(mockHost);
+    const about = await fixture.get("about");
+    assert(about instanceof OpenSiteTree);
+    assert.equal(about.href, "https://mock/about/");
+  });
+
+  test("can convert a site to a plain object", async () => {
+    const fixture = new OpenSiteTree(mockHost);
+    // Convert buffers to strings.
+    const strings = Tree.map(fixture, (value) => textDecoder.decode(value));
+    assert.deepEqual(await Tree.plain(strings), {
+      about: {
+        "Alice.html": "Hello, Alice!",
+        "Bob.html": "Hello, Bob!",
+        "Carol.html": "Hello, Carol!",
+      },
+      "index.html": "Home page",
+    });
+  });
+});
+
+async function mockFetch(href) {
+  if (!href.startsWith(mockHost)) {
+    return { status: 404 };
+  }
+  const path = href.slice(mockHost.length);
+  const mockedResponse = mockResponses[path];
+  if (mockedResponse) {
+    return Object.assign(
+      {
+        arrayBuffer: () => textEncoder.encode(mockedResponse.data).buffer,
+        ok: true,
+        status: 200,
+        text: () => mockedResponse.data,
+      },
+      mockedResponse
+    );
+  }
+  return {
+    ok: false,
+    status: 404,
+  };
+}

package/test/SiteTree.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
 import SiteTree from "../src/SiteTree.js";
-import { Tree } from "../src/internal.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -9,17 +8,11 @@ const textEncoder = new TextEncoder();
 const mockHost = "https://mock";
 
 const mockResponses = {
-  "/.keys.json": {
-    data: JSON.stringify(["about/"]),
-  },
   "/about": {
     redirected: true,
     status: 301,
     url: "https://mock/about/",
   },
-  "/about/.keys.json": {
-    data: JSON.stringify(["Alice.html", "Bob.html", "Carol.html"]),
-  },
   "/about/Alice.html": {
     data: "Hello, Alice!",
   },
@@ -29,6 +22,9 @@ const mockResponses = {
   "/about/Carol.html": {
     data: "Hello, Carol!",
   },
+  "/index.html": {
+    data: "Home page",
+  },
 };
 
 describe("SiteTree", () => {
@@ -36,29 +32,24 @@ describe("SiteTree", () => {
     mock.method(global, "fetch", mockFetch);
   });
 
-  test("resolve() returns a new SiteTree for the given relative route", () => {
+  test("returns an empty array as the keys of a tree", async () => {
     const fixture = new SiteTree(mockHost);
-    const about = fixture.resolve("about");
-    assert.equal(about.href, "https://mock/about/");
+    const keys = await fixture.keys();
+    assert.deepEqual(Array.from(keys), []);
   });
 
-  test("can get the keys of the tree", async () => {
+  test("can get a plain value for a key", async () => {
     const fixture = new SiteTree(mockHost);
-    const about = fixture.resolve("about");
-    const keys = await about.keys();
-    assert.deepEqual(Array.from(keys), [
-      "Alice.html",
-      "Bob.html",
-      "Carol.html",
-    ]);
+    const arrayBuffer = await fixture.get("index.html");
+    const text = textDecoder.decode(arrayBuffer);
+    assert.equal(text, "Home page");
   });
 
-  test("can get the value for a key", async () => {
+  test("immediately return a new tree for a key with a trailing slash", async () => {
     const fixture = new SiteTree(mockHost);
-    const about = fixture.resolve("about");
-    const arrayBuffer = await about.get("Alice.html");
-    const text = textDecoder.decode(arrayBuffer);
-    assert.equal(text, "Hello, Alice!");
+    const about = await fixture.get("about/");
+    assert(about instanceof SiteTree);
+    assert.equal(about.href, "https://mock/about/");
   });
 
   test("getting an unsupported key returns undefined", async () => {
@@ -75,32 +66,6 @@ describe("SiteTree", () => {
       await fixture.get(undefined);
     });
   });
-
-  test("a redirect on a site with keys returns a SiteTree for the new URL", async () => {
-    const fixture = new SiteTree(mockHost);
-    const about = await fixture.get("about");
-    assert.equal(about.href, "https://mock/about/");
-  });
-
-  test("can determine whether a key is for a subtree", async () => {
-    const fixture = new SiteTree(mockHost);
-    assert.equal(await fixture.isKeyForSubtree("about"), true);
-    const about = fixture.resolve("about");
-    assert.equal(await about.isKeyForSubtree("Alice.html"), false);
-  });
-
-  test("can convert a SiteGraph to a plain object", async () => {
-    const fixture = new SiteTree(mockHost);
-    // Convert buffers to strings.
-    const strings = Tree.map(fixture, (value) => textDecoder.decode(value));
-    assert.deepEqual(await Tree.plain(strings), {
-      about: {
-        "Alice.html": "Hello, Alice!",
-        "Bob.html": "Hello, Bob!",
-        "Carol.html": "Hello, Carol!",
-      },
-    });
-  });
 });
 
 async function mockFetch(href) {

package/test/Tree.test.js

@@ -31,7 +31,8 @@ describe("Tree", () => {
     const result = await Tree.assign(target, source);
 
     assert.equal(result, target);
-    assert.deepEqual(await Tree.plain(target), {
+    const plain = await Tree.plain(target);
+    assert.deepEqual(plain, {
       a: 4,
       c: 5,
       more: {
@@ -171,17 +172,6 @@ describe("Tree", () => {
     assert(Tree.isTreelike(new Set()));
   });
 
-  test("isKeyForSubtree() returns true if the key is for a subtree", async () => {
-    const tree = new DeepObjectTree({
-      a: 1,
-      more: {
-        b: 2,
-      },
-    });
-    assert(!(await Tree.isKeyForSubtree(tree, "a")));
-    assert(await Tree.isKeyForSubtree(tree, "more"));
-  });
-
   test("map() maps values", async () => {
     const tree = new DeepObjectTree({
       a: "Alice",
@@ -228,18 +218,26 @@ describe("Tree", () => {
   });
 
   test("plain() produces a plain object version of a tree", async () => {
-    const original = {
+    const tree = new ObjectTree({
       a: 1,
-      b: 2,
-      c: 3,
-      more: {
-        d: 4,
-        e: 5,
+      // Slashes should be normalized
+      "sub1/": {
+        b: 2,
       },
-    };
-    const tree = new ObjectTree(original);
+      sub2: {
+        c: 3,
+      },
+    });
     const plain = await Tree.plain(tree);
-    assert.deepEqual(plain, original);
+    assert.deepEqual(plain, {
+      a: 1,
+      sub1: {
+        b: 2,
+      },
+      sub2: {
+        c: 3,
+      },
+    });
   });
 
   test("plain() produces an array for an array-like tree", async () => {
@@ -335,24 +333,6 @@ describe("Tree", () => {
     assert.equal(await Tree.traverse(tree, "a", "b", "c"), "Hello");
   });
 
-  test("traversing a final empty string can unpack the last value", async () => {
-    const unpackable = new String();
-    /** @type {any} */ (unpackable).unpack = () => "Content";
-    const tree = {
-      unpackable,
-    };
-    const result = await Tree.traverse(tree, "unpackable", "");
-    assert.equal(result, "Content");
-  });
-
-  test("traversing a final empty string returns a value as is if it's not unpackable", async () => {
-    const tree = new ObjectTree({
-      a: "Hello",
-    });
-    const result = await Tree.traverse(tree, "a", "");
-    assert.equal(result, "Hello");
-  });
-
   test("traversePath() traverses a slash-separated path", async () => {
     const tree = new ObjectTree({
       a: {

package/test/browser/assert.js

@@ -43,3 +43,12 @@ assert.deepEqual = (actual, expected) => {
 
   throw new Error(`Expected ${expected} but got ${actual}`);
 };
+
+assert.rejects = async (promise) => {
+  try {
+    await promise;
+    throw new Error("Expected promise to reject but it resolved");
+  } catch (error) {
+    return;
+  }
+};

package/test/browser/index.html

@@ -22,13 +22,13 @@
     <script type="module" src="../Tree.test.js"></script>
     <script type="module" src="../operations/cache.test.js"></script>
     <script type="module" src="../operations/merge.test.js"></script>
-    <script type="module" src="../operations/mergeDeep.test.js"></script>
-    <script type="module" src="../transforms/cachedKeyFns.test.js"></script>
+    <script type="module" src="../operations/deepMerge.test.js"></script>
+    <script type="module" src="../transforms/cachedKeyMaps.test.js"></script>
     <script
       type="module"
-      src="../transforms/keyMapsForExtensions.test.js"
+      src="../transforms/keyFunctionsForExtensions.test.js"
     ></script>
-    <script type="module" src="../transforms/map.test.js"></script>
+    <script type="module" src="../transforms/mapFn.test.js"></script>
     <script type="module" src="../utilities.test.js"></script>
   </head>
   <body></body>