@weborigami/async-tree 0.2.7 → 0.2.9

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.10.2",
-    "typescript": "5.7.2"
+    "@types/node": "22.13.5",
+    "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/types": "0.2.7"
+    "@weborigami/types": "0.2.9"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/extension.js

@@ -65,7 +65,7 @@ export function extname(path) {
  * See if the key ends with the given extension. If it does, return the base
  * name without the extension; if it doesn't return null.
  *
- * If the extension is empty, the key must not have an extension to match.
+ * If the extension is the empty string, this will match any key.
  *
  * If the extension is a slash, then the key must end with a slash for the match
  * to succeed. Otherwise, a trailing slash in the key is ignored for purposes of

package/src/operations/cachedKeyFunctions.js

@@ -6,16 +6,16 @@ const treeToCaches = new Map();
  * Given a key function, return a new key function and inverse key function that
  * cache the results of the original.
  *
- * If `skipSubtrees` is true, the inverse key function will skip any source keys
- * that are keys for subtrees, returning the source key unmodified.
+ * If `deep` is true, the inverse key function will skip any source keys that
+ * are keys for subtrees, returning the source key unmodified.
  *
  * @typedef {import("../../index.ts").KeyFn} KeyFn
  *
  * @param {KeyFn} keyFn
- * @param {boolean?} skipSubtrees
+ * @param {boolean?} deep
  * @returns {{ key: KeyFn, inverseKey: KeyFn }}
  */
-export default function cachedKeyFunctions(keyFn, skipSubtrees = false) {
+export default function cachedKeyFunctions(keyFn, deep = false) {
   return {
     async inverseKey(resultKey, tree) {
       const { resultKeyToSourceKey, sourceKeyToResultKey } =
@@ -40,7 +40,7 @@ export default function cachedKeyFunctions(keyFn, skipSubtrees = false) {
         const computedResultKey = await computeAndCacheResultKey(
           tree,
           keyFn,
-          skipSubtrees,
+          deep,
           sourceKey
         );
 
@@ -48,8 +48,8 @@ export default function cachedKeyFunctions(keyFn, skipSubtrees = false) {
           computedResultKey &&
           trailingSlash.remove(computedResultKey) === resultKeyWithoutSlash
         ) {
-          // Match found, match trailing slash and return
-          return trailingSlash.toggle(sourceKey, trailingSlash.has(resultKey));
+          // Match found
+          return matchSlashHandling(computedResultKey, sourceKey, resultKey);
         }
       }
 
@@ -67,7 +67,7 @@ export default function cachedKeyFunctions(keyFn, skipSubtrees = false) {
       const resultKey = await computeAndCacheResultKey(
         tree,
         keyFn,
-        skipSubtrees,
+        deep,
         sourceKey
       );
       return resultKey;
@@ -75,12 +75,12 @@ export default function cachedKeyFunctions(keyFn, skipSubtrees = false) {
   };
 }
 
-async function computeAndCacheResultKey(tree, keyFn, skipSubtrees, sourceKey) {
+async function computeAndCacheResultKey(tree, keyFn, deep, sourceKey) {
   const { resultKeyToSourceKey, sourceKeyToResultKey } =
     getKeyMapsForTree(tree);
 
   const resultKey =
-    skipSubtrees && trailingSlash.has(sourceKey)
+    deep && trailingSlash.has(sourceKey)
       ? sourceKey
       : await keyFn(sourceKey, tree);
 
@@ -104,19 +104,33 @@ function getKeyMapsForTree(tree) {
   return keyMaps;
 }
 
-// Search the given key map for the key. Ignore trailing slashes in the search,
-// but preserve them in the result.
-function searchKeyMap(keyMap, key) {
+// Given the input key passed to a function and the result of that function, and
+// a requested key being searched for, determine whether we should add a slash
+// to the output key.
+function matchSlashHandling(inputKey, outputKey, requestedKey) {
+  if (trailingSlash.has(inputKey) !== trailingSlash.has(outputKey)) {
+    // The key function toggled the slash on the input key; return output as is
+    return outputKey;
+  } else {
+    // Match the slash handling of the requested key
+    return trailingSlash.toggle(outputKey, trailingSlash.has(requestedKey));
+  }
+}
+
+// Search the given key map for the key. Ignore trailing slashes in the search.
+function searchKeyMap(keyMap, requestedKey) {
   // Check key as is
-  let match;
-  if (keyMap.has(key)) {
-    match = keyMap.get(key);
+  let resultKey;
+  let sourceKey = requestedKey;
+  if (keyMap.has(sourceKey)) {
+    resultKey = keyMap.get(requestedKey);
   } else {
     // Check alternative with/without slash
-    const alternativeKey = trailingSlash.toggle(key, !trailingSlash.has(key));
-    match = keyMap.get(alternativeKey);
+    sourceKey = trailingSlash.toggle(requestedKey);
+    resultKey = keyMap.get(sourceKey);
+  }
+  if (resultKey === undefined) {
+    return undefined;
   }
-  return match
-    ? trailingSlash.toggle(match, trailingSlash.has(key))
-    : undefined;
+  return matchSlashHandling(sourceKey, resultKey, requestedKey);
 }

package/src/operations/keyFunctionsForExtensions.js

@@ -2,15 +2,14 @@ import * as extension from "../extension.js";
 import * as trailingSlash from "../trailingSlash.js";
 
 /**
- * Given a source resultExtension and a result resultExtension, return a pair of key
+ * Given a source extension and a result extension, return a pair of key
  * functions that map between them.
  *
  * The resulting `inverseKey` and `key` functions are compatible with those
  * expected by map and other transforms.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @param {{ resultExtension?: string, sourceExtension: string }}
- * options
+ * @param {{ resultExtension?: string, sourceExtension: string }} options
  */
 export default function keyFunctionsForExtensions({
   resultExtension,
@@ -42,7 +41,7 @@ export default function keyFunctionsForExtensions({
 function checkDeprecatedExtensionWithoutDot(extension) {
   if (extension && extension !== "/" && !extension.startsWith(".")) {
     throw new RangeError(
-      `map: Warning: the extension "${extension}" should start with a period.`
+      `The extension "${extension}" must start with a period.`
     );
   }
 }

package/src/utilities.d.ts

@@ -7,6 +7,7 @@ export function getRealmObjectPrototype(object: any): any;
 export const hiddenFileNames: string[];
 export function isPacked(obj: any): obj is Packed;
 export function isPlainObject(obj: any): obj is PlainObject;
+export function isPrimitive(obj: any): boolean;
 export function isStringLike(obj: any): obj is StringLike;
 export function isUnpackable(obj): obj is { unpack: () => any };
 export function keysFromPath(path: string): string[];

package/test/extension.test.js

@@ -19,6 +19,7 @@ describe("extension", () => {
     assert.equal(match("file.md", ".txt"), null);
     assert.equal(match("file.md/", ".md"), "file/");
     assert.equal(match("file", ""), "file");
+    assert.equal(match("file.md", ""), "file.md");
     assert.equal(match("file", "/"), null);
     assert.equal(match("file/", "/"), "file");
   });

package/test/operations/cachedKeyFunctions.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
 import cachedKeyFunctions from "../../src/operations/cachedKeyFunctions.js";
+import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("cachedKeyFunctions", () => {
   test("maps keys with caching", async () => {
@@ -74,7 +75,7 @@ describe("cachedKeyFunctions", () => {
     assert.equal(callCount, 1);
   });
 
-  test("preserves trailing slashes", async () => {
+  test("preserves trailing slashes if key function does so", async () => {
     const tree = new ObjectTree({
       a: "letter a",
     });
@@ -87,4 +88,19 @@ describe("cachedKeyFunctions", () => {
     assert.equal(await inverseKey("_a/", tree), "a/");
     assert.equal(await inverseKey("_a", tree), "a");
   });
+
+  test("if key function toggles slash, defers to key function slash handling", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+    });
+    const addUnderscoreAndSlash = async (sourceKey) =>
+      `_${trailingSlash.remove(sourceKey)}/`;
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscoreAndSlash);
+
+    assert.equal(await inverseKey("_a/", tree), "a");
+    assert.equal(await inverseKey("_a", tree), "a");
+
+    assert.equal(await key("a", tree), "_a/");
+    assert.equal(await key("a/", tree), "_a/");
+  });
 });