@weborigami/async-tree 0.0.37 → 0.0.39

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.8.10",
-    "typescript": "5.2.2"
+    "@types/node": "20.11.3",
+    "typescript": "5.3.3"
   },
   "dependencies": {
     "@weborigami/types": "*"

package/src/operations/cache.js

@@ -32,9 +32,9 @@ export default function treeCache(source, cacheTree, filter) {
       // Cache miss or interior node cache hit.
       let value = await source.get(key);
       if (value !== undefined) {
-        // Does this key match the filter?
-        const filterValue = filter ? await filter.get(key) : true;
-        const filterMatch = filterValue !== undefined;
+        // If a filter is defined, does the key match the filter?
+        const filterValue = await filter?.get(key);
+        const filterMatch = !filter || filterValue !== undefined;
         if (filterMatch) {
           if (Tree.isAsyncTree(value)) {
             // Construct merged tree for a tree result.

package/src/transforms/map.js

@@ -6,25 +6,35 @@ import * as Tree from "../Tree.js";
  * @typedef {import("../../index.ts").KeyFn} KeyFn
  * @typedef {import("../../index.ts").ValueKeyFn} ValueKeyFn
  *
- * @param {ValueKeyFn|{ deep?: boolean, description?: string, inverseKeyMap?: KeyFn, keyMap?: KeyFn, valueMap?: ValueKeyFn }} options
+ * @param {ValueKeyFn|{ deep?: boolean, description?: string, needsSourceValue?: boolean, inverseKeyMap?: KeyFn, keyMap?: KeyFn, valueMap?: ValueKeyFn }} options
  */
 export default function createMapTransform(options) {
   let deep;
   let description;
   let inverseKeyMap;
   let keyMap;
+  let needsSourceValue;
   let valueMap;
   if (typeof options === "function") {
     // Take the single function argument as the valueMap
     valueMap = options;
   } else {
-    deep = options.deep ?? false;
-    description = options.description ?? "key/value map";
+    deep = options.deep;
+    description = options.description;
     inverseKeyMap = options.inverseKeyMap;
     keyMap = options.keyMap;
+    needsSourceValue = options.needsSourceValue;
     valueMap = options.valueMap;
   }
 
+  deep ??= false;
+  description ??= "key/value map";
+  // @ts-ignore
+  inverseKeyMap ??= valueMap?.inverseKeyMap;
+  // @ts-ignore
+  keyMap ??= valueMap?.keyMap;
+  needsSourceValue ??= true;
+
   if ((keyMap && !inverseKeyMap) || (!keyMap && inverseKeyMap)) {
     throw new TypeError(
       `map: You must specify both keyMap and inverseKeyMap, or neither.`
@@ -58,11 +68,18 @@ export default function createMapTransform(options) {
         }
 
         // Step 2: Get the source value.
-        const sourceValue = await tree.get(sourceKey);
+        let sourceValue;
+        if (needsSourceValue) {
+          // Normal case: get the value from the source tree.
+          sourceValue = await tree.get(sourceKey);
+        } else if (deep && (await Tree.isKeyForSubtree(tree, sourceKey))) {
+          // Only get the source value if it's a subtree.
+          sourceValue = tree;
+        }
 
         // Step 3: Map the source value to the result value.
         let resultValue;
-        if (sourceValue === undefined) {
+        if (needsSourceValue && sourceValue === undefined) {
           // No source value means no result value.
           resultValue = undefined;
         } else if (deep && Tree.isAsyncTree(sourceValue)) {

package/test/transforms/map.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import FunctionTree from "../../src/FunctionTree.js";
 import ObjectTree from "../../src/ObjectTree.js";
 import * as Tree from "../../src/Tree.js";
 import map from "../../src/transforms/map.js";
@@ -108,6 +109,21 @@ describe("map", () => {
     });
   });
 
+  test("valueMap can provide a default keyMap and inverseKeyMap", async () => {
+    const uppercase = (s) => s.toUpperCase();
+    uppercase.keyMap = (sourceKey) => `_${sourceKey}`;
+    uppercase.inverseKeyMap = (resultKey) => resultKey.slice(1);
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    const mapped = map(uppercase)(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "LETTER A",
+      _b: "LETTER B",
+    });
+  });
+
   test("deep maps values", async () => {
     const tree = new ObjectTree({
       a: "letter a",
@@ -171,4 +187,21 @@ describe("map", () => {
       },
     });
   });
+
+  test("needsSourceValue can be set to false in cases where the value isn't necessary", async () => {
+    let flag = false;
+    const tree = new FunctionTree(() => {
+      flag = true;
+    }, ["a", "b", "c"]);
+    const mapped = map({
+      needsSourceValue: false,
+      valueMap: () => "X",
+    })(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      a: "X",
+      b: "X",
+      c: "X",
+    });
+    assert(!flag);
+  });
 });