npm - @weborigami/async-tree - Versions diffs - 0.0.65 → 0.0.66-beta.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/main.js +2 -0
package/package.json +4 -4
package/src/BrowserFileTree.js +28 -6
package/src/DeepMapTree.js +2 -2
package/src/DeepObjectTree.js +6 -9
package/src/FileTree.js +14 -10
package/src/MapTree.js +27 -4
package/src/ObjectTree.js +53 -6
package/src/OpenSiteTree.js +41 -0
package/src/SetTree.js +0 -6
package/src/SiteTree.js +24 -85
package/src/Tree.d.ts +1 -2
package/src/Tree.js +40 -52
package/src/jsonKeys.js +4 -37
package/src/operations/cache.js +0 -4
package/src/operations/deepMerge.js +7 -10
package/src/operations/merge.js +7 -10
package/src/trailingSlash.js +54 -0
package/src/transforms/cachedKeyFunctions.js +72 -34
package/src/transforms/keyFunctionsForExtensions.js +24 -10
package/src/transforms/mapFn.js +11 -17
package/src/transforms/regExpKeys.js +17 -12
package/src/utilities.js +34 -6
package/test/BrowserFileTree.test.js +28 -5
package/test/DeepMapTree.test.js +17 -0
package/test/DeepObjectTree.test.js +17 -7
package/test/FileTree.test.js +14 -7
package/test/MapTree.test.js +21 -0
package/test/ObjectTree.test.js +16 -12
package/test/OpenSiteTree.test.js +113 -0
package/test/SiteTree.test.js +14 -49
package/test/Tree.test.js +19 -39
package/test/browser/assert.js +9 -0
package/test/browser/index.html +4 -4
package/test/calendarTree.test.js +1 -1
package/test/fixtures/markdown/subfolder/README.md +1 -0
package/test/jsonKeys.test.js +0 -9
package/test/operations/cache.test.js +1 -1
package/test/operations/merge.test.js +20 -1
package/test/trailingSlash.test.js +36 -0
package/test/transforms/cachedKeyFunctions.test.js +90 -0
package/test/transforms/keyFunctionsForExtensions.test.js +7 -3
package/test/transforms/mapFn.test.js +29 -20
package/test/utilities.test.js +6 -2
package/test/transforms/cachedKeyMaps.test.js +0 -41

package/test/Tree.test.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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>

package/test/calendarTree.test.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { toPlainValue } from "../main.js";
 import calendarTree from "../src/calendarTree.js";
+import { toPlainValue } from "../src/utilities.js";
 describe("calendarTree", () => {
   test("without a start or end, returns a tree for today", async () => {

package/test/fixtures/markdown/subfolder/README.md ADDED Viewed

	@@ -0,0 +1 @@
1	+ This file exists to force the creation of the parent folder.

package/test/jsonKeys.test.js CHANGED Viewed

@@ -4,15 +4,6 @@ import { describe, test } from "node:test";
 import * as jsonKeys from "../src/jsonKeys.js";
 describe("jsonKeys", () => {
-  test("parses JSON Keys", async () => {
-    const json = '["index.html","about/"]';
-    const parsed = jsonKeys.parse(json);
-    assert.deepStrictEqual(parsed, {
-      "index.html": false,
-      about: true,
-    });
-  });
   test("stringifies JSON Keys", async () => {
     const tree = new DeepObjectTree({
       about: {},

package/test/operations/cache.test.js CHANGED Viewed

@@ -19,7 +19,7 @@ describe("cache", () => {
     );
     const keys = [...(await fixture.keys())];
-    assert.deepEqual(keys, ["a", "b", "c", "more"]);
+    assert.deepEqual(keys, ["a", "b", "c", "more/"]);
     assert.equal(await objectCache.get("a"), undefined);
     assert.equal(await fixture.get("a"), 1);

package/test/operations/merge.test.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import merge from "../../src/operations/merge.js";
 import * as symbols from "../../src/symbols.js";
@@ -42,4 +42,23 @@ describe("merge", () => {
     const b = await fixture.get("b");
     assert.equal(b[symbols.parent], fixture);
   });
+  test("subtree can overwrite a leaf node", async () => {
+    const fixture = merge(
+      new ObjectTree({
+        a: 1,
+      }),
+      new DeepObjectTree({
+        a: {
+          b: 2,
+        },
+      })
+    );
+    assert.deepEqual([...(await fixture.keys())], ["a/"]);
+    assert.deepEqual(await Tree.plain(fixture), {
+      a: {
+        b: 2,
+      },
+    });
+  });
 });

package/test/trailingSlash.test.js ADDED Viewed

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { add, has, remove, toggle } from "../src/trailingSlash.js";
+describe("trailingSlash", () => {
+  test("add adds a trailing slash to a string key for a truthy value", () => {
+    assert.equal(add("key"), "key/");
+    assert.equal(add("key/"), "key/");
+    assert.equal(add(1), 1);
+  });
+  test("has returns true if a string key has a trailing slash", () => {
+    assert.equal(has("key/"), true);
+    assert.equal(has("key"), false);
+    assert.equal(has(1), false);
+  });
+  test("remove removes a trailing slash from a string key", () => {
+    assert.equal(remove("key/"), "key");
+    assert.equal(remove("key"), "key");
+    assert.equal(remove(1), 1);
+  });
+  test("toggle removes a slash if present, adds one if not", () => {
+    assert.equal(toggle("key/"), "key");
+    assert.equal(toggle("key"), "key/");
+    assert.equal(toggle(1), 1);
+  });
+  test("toggle can force toggling on or off", () => {
+    assert.equal(toggle("key/", false), "key");
+    assert.equal(toggle("key/", true), "key/");
+    assert.equal(toggle("key", false), "key");
+    assert.equal(toggle("key", true), "key/");
+  });
+});

package/test/transforms/cachedKeyFunctions.test.js ADDED Viewed

@@ -0,0 +1,90 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
+describe("cachedKeyFunctions", () => {
+  test("maps keys with caching", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    let callCount = 0;
+    const addUnderscore = async (sourceKey, tree) => {
+      callCount++;
+      return `_${sourceKey}`;
+    };
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore);
+    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKey("_a", tree), "a");
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKey("_b", tree), "b"); // Cache miss
+    assert.equal(callCount, 2);
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("b", tree), "_b");
+    assert.equal(callCount, 2);
+    // `c` isn't in tree, so we should get undefined.
+    assert.equal(await inverseKey("_c", tree), undefined);
+    // But key mapping is still possible.
+    assert.equal(await key("c", tree), "_c");
+    // And now we have a cache hit.
+    assert.equal(await inverseKey("_c", tree), "c");
+    assert.equal(callCount, 3);
+  });
+  test("maps keys with caching and deep option", async () => {
+    const tree = new DeepObjectTree({
+      a: "letter a",
+      b: {
+        c: "letter c",
+      },
+    });
+    let callCount = 0;
+    const addUnderscore = async (sourceKey, tree) => {
+      callCount++;
+      return `_${sourceKey}`;
+    };
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore, true);
+    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
+    assert.equal(await inverseKey("_a", tree), "a");
+    assert.equal(callCount, 1);
+    // Subtree key left alone
+    assert.equal(await inverseKey("_b", tree), undefined);
+    assert.equal(await inverseKey("b", tree), "b");
+    assert.equal(await inverseKey("b/", tree), "b/");
+    assert.equal(callCount, 1);
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(callCount, 1);
+    assert.equal(await key("b/", tree), "b/");
+    assert.equal(await key("b", tree), "b");
+    assert.equal(callCount, 1);
+  });
+  test("preserves trailing slashes", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+    });
+    const addUnderscore = async (sourceKey) => `_${sourceKey}`;
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore);
+    assert.equal(await key("a/", tree), "_a/");
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await inverseKey("_a/", tree), "a/");
+    assert.equal(await inverseKey("_a", tree), "a");
+  });
+});

package/test/transforms/keyFunctionsForExtensions.test.js CHANGED Viewed

@@ -10,18 +10,22 @@ describe("keyMapsForExtensions", () => {
       sourceExtension: "txt",
     });
     assert.equal(await inverseKey("file.txt"), "file.txt");
+    assert.equal(await inverseKey("file.txt/"), "file.txt");
     assert.equal(await key("file.txt"), "file.txt");
+    assert.equal(await key("file.txt/"), "file.txt/");
     assert.equal(await inverseKey("file.foo"), undefined);
     assert.equal(await key("file.foo"), undefined);
   });
   test("returns key functions that can map extensions", async () => {
     const { inverseKey, key } = keyFunctionsForExtensions({
-      resultExtension: "html",
+      resultExtension: "json",
       sourceExtension: "md",
     });
-    assert.equal(await inverseKey("file.html"), "file.md");
-    assert.equal(await key("file.md"), "file.html");
+    assert.equal(await inverseKey("file.json"), "file.md");
+    assert.equal(await inverseKey("file.json/"), "file.md");
+    assert.equal(await key("file.md"), "file.json");
+    assert.equal(await key("file.md/"), "file.json/");
     assert.equal(await inverseKey("file.foo"), undefined);
     assert.equal(await key("file.foo"), undefined);
   });

package/test/transforms/mapFn.test.js CHANGED Viewed

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import FunctionTree from "../../src/FunctionTree.js";
 import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+import * as trailingSlash from "../../src/trailingSlash.js";
 import mapFn from "../../src/transforms/mapFn.js";
 describe("mapFn", () => {
@@ -59,11 +60,11 @@ describe("mapFn", () => {
       a: "letter a",
       b: "letter b",
     };
-    const doubleKeys = mapFn({
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+    const underscopeKeys = mapFn({
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscopeKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "letter a",
       _b: "letter b",
@@ -75,12 +76,12 @@ describe("mapFn", () => {
       a: "letter a",
       b: "letter b",
     };
-    const doubleKeysUppercaseValues = mapFn({
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+    const underscoreKeysUppercaseValues = mapFn({
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
       value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    const mapped = doubleKeysUppercaseValues(tree);
+    const mapped = underscoreKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
       _b: "LETTER B",
@@ -94,12 +95,12 @@ describe("mapFn", () => {
         b: "letter b",
       },
     };
-    const doubleKeys = mapFn({
+    const underscopeKeys = mapFn({
       key: async (sourceKey, tree) => `_${sourceKey}`,
       inverseKey: async (resultKey, tree) => resultKey.slice(1),
       value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscopeKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "a",
       _more: "more",
@@ -108,8 +109,8 @@ describe("mapFn", () => {
   test("value can provide a default key and inverse key functions", async () => {
     const uppercase = (s) => s.toUpperCase();
-    uppercase.key = (sourceKey) => `_${sourceKey}`;
-    uppercase.inverseKey = (resultKey) => resultKey.slice(1);
+    uppercase.key = addUnderscore;
+    uppercase.inverseKey = removeUnderscore;
     const tree = {
       a: "letter a",
       b: "letter b",
@@ -148,12 +149,12 @@ describe("mapFn", () => {
         b: "letter b",
       },
     });
-    const doubleKeys = mapFn({
+    const underscoreKeys = mapFn({
       deep: true,
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscoreKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "letter a",
       more: {
@@ -169,13 +170,13 @@ describe("mapFn", () => {
         b: "letter b",
       },
     });
-    const doubleKeysUppercaseValues = mapFn({
+    const underscoreKeysUppercaseValues = mapFn({
       deep: true,
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
       value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    const mapped = doubleKeysUppercaseValues(tree);
+    const mapped = underscoreKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
       more: {
@@ -201,3 +202,11 @@ describe("mapFn", () => {
     assert(!flag);
   });
 });
+function addUnderscore(key) {
+  return `_${key}`;
+}
+function removeUnderscore(key) {
+  return trailingSlash.has(key) ? key : key.slice(1);
+}

package/test/utilities.test.js CHANGED Viewed

@@ -41,8 +41,12 @@ describe("utilities", () => {
   });
   test("keysFromPath() returns the keys from a slash-separated path", () => {
-    assert.deepEqual(utilities.keysFromPath("a/b/c"), ["a", "b", "c"]);
-    assert.deepEqual(utilities.keysFromPath("foo/"), ["foo", ""]);
+    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", () => {

package/test/transforms/cachedKeyMaps.test.js DELETED Viewed

@@ -1,41 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { ObjectTree } from "../../src/internal.js";
-import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
-describe("cachedKeyFunctions", () => {
-  test("maps keys with caching", async () => {
-    const tree = new ObjectTree({
-      a: "letter a",
-      b: "letter b",
-    });
-    let callCount = 0;
-    const underscoreKeys = async (sourceKey, tree) => {
-      callCount++;
-      return `_${sourceKey}`;
-    };
-    const { inverseKey, key } = cachedKeyFunctions(underscoreKeys);
-    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
-    assert.equal(callCount, 1);
-    assert.equal(await inverseKey("_a", tree), "a");
-    assert.equal(callCount, 1);
-    assert.equal(await inverseKey("_b", tree), "b"); // Cache miss
-    assert.equal(callCount, 2);
-    assert.equal(await key("a", tree), "_a");
-    assert.equal(await key("a", tree), "_a");
-    assert.equal(await key("b", tree), "_b");
-    assert.equal(callCount, 2);
-    // `c` isn't in tree, so we should get undefined.
-    assert.equal(await inverseKey("_c", tree), undefined);
-    // But key mapping is still possible.
-    assert.equal(await key("c", tree), "_c");
-    // And now we have a cache hit.
-    assert.equal(await inverseKey("_c", tree), "c");
-    assert.equal(callCount, 3);
-  });
-});