@weborigami/async-tree 0.0.44 → 0.0.46

package/index.ts

@@ -35,7 +35,7 @@ export type Treelike =
   NativeTreelike |
   Unpackable<NativeTreelike>;
 
-export type TreeTransform = (tree: AsyncTree) => AsyncTree;
+export type TreeTransform = (treelike: Treelike) => AsyncTree;
 
 export type Unpackable<T> = {
   unpack(): Promise<T>

package/main.js

@@ -15,9 +15,9 @@ export * as keysJson from "./src/keysJson.js";
 export { default as cache } from "./src/operations/cache.js";
 export { default as merge } from "./src/operations/merge.js";
 export { default as mergeDeep } from "./src/operations/mergeDeep.js";
-export { default as cachedKeyMaps } from "./src/transforms/cachedKeyMaps.js";
+export { default as cachedKeyFunctions } from "./src/transforms/cachedKeyFunctions.js";
 export { default as groupBy } from "./src/transforms/groupBy.js";
-export { default as keyMapsForExtensions } from "./src/transforms/keyMapsForExtensions.js";
+export { default as keyFunctionsForExtensions } from "./src/transforms/keyFunctionsForExtensions.js";
 export { default as map } from "./src/transforms/map.js";
 export { default as sort } from "./src/transforms/sort.js";
 export { default as sortBy } from "./src/transforms/sortBy.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.3.3"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.44"
+    "@weborigami/types": "0.0.46"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/FileTree.js

@@ -128,12 +128,15 @@ export default class FileTree {
       return this;
     }
 
-    // Treat null value as empty string; will create an empty file.
-    if (value === null) {
-      value = "";
+    if (typeof value === "function") {
+      // Invoke function; write out the result.
+      value = await value();
     }
 
-    if (value instanceof ArrayBuffer) {
+    if (value === null) {
+      // Treat null value as empty string; will create an empty file.
+      value = "";
+    } else if (value instanceof ArrayBuffer) {
       // Convert ArrayBuffer to Uint8Array, which Node.js can write directly.
       value = new Uint8Array(value);
     }

package/src/Tree.d.ts

@@ -11,7 +11,7 @@ export function isAsyncMutableTree(obj: any): obj is AsyncMutableTree;
 export function isAsyncTree(obj: any): obj is AsyncTree;
 export function isKeyForSubtree(tree: AsyncTree, obj: any): Promise<boolean>;
 export function isTreelike(obj: any): obj is Treelike;
-export function map(tree: Treelike, valueMap: ValueKeyFn): AsyncTree;
+export function map(tree: Treelike, valueFn: ValueKeyFn): AsyncTree;
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn|null, reduceFn: ReduceFn): Promise<any>;
 export function plain(tree: Treelike): Promise<PlainObject>;
 export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;

package/src/Tree.js

@@ -212,11 +212,11 @@ export async function isKeyForSubtree(tree, key) {
  * Return a new tree with deeply-mapped values of the original tree.
  *
  * @param {Treelike} treelike
- * @param {ValueKeyFn} valueMap
+ * @param {ValueKeyFn} valueFn
  */
-export function map(treelike, valueMap) {
+export function map(treelike, valueFn) {
   const tree = from(treelike);
-  return mapTransform({ deep: true, valueMap })(tree);
+  return mapTransform({ deep: true, value: valueFn })(tree);
 }
 
 /**
@@ -230,10 +230,10 @@ export function map(treelike, valueMap) {
  * reduceFn, which should consolidate those into a single result.
  *
  * @param {Treelike} treelike
- * @param {ValueKeyFn|null} valueMap
+ * @param {ValueKeyFn|null} valueFn
  * @param {ReduceFn} reduceFn
  */
-export async function mapReduce(treelike, valueMap, reduceFn) {
+export async function mapReduce(treelike, valueFn, reduceFn) {
   const tree = from(treelike);
 
   // We're going to fire off all the get requests in parallel, as quickly as
@@ -244,9 +244,9 @@ export async function mapReduce(treelike, valueMap, reduceFn) {
     tree.get(key).then((value) =>
       // If the value is a subtree, recurse.
       isAsyncTree(value)
-        ? mapReduce(value, valueMap, reduceFn)
-        : valueMap
-        ? valueMap(value, key, tree)
+        ? mapReduce(value, valueFn, reduceFn)
+        : valueFn
+        ? valueFn(value, key, tree)
         : value
     )
   );

package/src/operations/cache.js

@@ -9,13 +9,17 @@ import { ObjectTree, Tree } from "@weborigami/async-tree";
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/types").AsyncMutableTree} AsyncMutableTree
+ * @typedef {import("../../index.ts").Treelike} Treelike
  *
- * @param {AsyncTree} source
+ * @param {Treelike} sourceTreelike
  * @param {AsyncMutableTree} [cacheTree]
- * @param {AsyncTree} [filter]
+ * @param {Treelike} [filterTreelike]
  * @returns {AsyncTree & { description: string }}
  */
-export default function treeCache(source, cacheTree, filter) {
+export default function treeCache(sourceTreelike, cacheTree, filterTreelike) {
+  const source = Tree.from(sourceTreelike);
+  const filter = filterTreelike ? Tree.from(filterTreelike) : undefined;
+
   /** @type {AsyncMutableTree} */
   const cache = cacheTree ?? new ObjectTree({});
   return {

package/src/transforms/{cachedKeyMaps.js → cachedKeyFunctions.js}

@@ -3,18 +3,18 @@ import * as Tree from "../Tree.js";
 const treeToCaches = new WeakMap();
 
 /**
- * Given a keyMap, return a new keyMap and inverseKeyMap that cache the results of
- * the original keyMap.
+ * Given a key function, return a new key function and inverse key function that
+ * cache the results of the original.
  *
  * @typedef {import("../../index.ts").KeyFn} KeyFn
  *
- * @param {KeyFn} keyMap
+ * @param {KeyFn} keyFn
  * @param {boolean} [deep]
- * @returns {{ keyMap: KeyFn, inverseKeyMap: KeyFn }}
+ * @returns {{ key: KeyFn, inverseKey: KeyFn }}
  */
-export default function createCachedKeysTransform(keyMap, deep = false) {
+export default function createCachedKeysTransform(keyFn, deep = false) {
   return {
-    async inverseKeyMap(resultKey, tree) {
+    async inverseKey(resultKey, tree) {
       const caches = getCachesForTree(tree);
 
       // First check to see if we've already computed an source key for this
@@ -37,7 +37,7 @@ export default function createCachedKeysTransform(keyMap, deep = false) {
         if (deep && (await Tree.isKeyForSubtree(tree, sourceKey))) {
           computedResultKey = sourceKey;
         } else {
-          computedResultKey = await keyMap(sourceKey, tree);
+          computedResultKey = await keyFn(sourceKey, tree);
         }
 
         caches.sourceKeyToResultKey.set(sourceKey, computedResultKey);
@@ -52,7 +52,7 @@ export default function createCachedKeysTransform(keyMap, deep = false) {
       return undefined;
     },
 
-    async keyMap(sourceKey, tree) {
+    async key(sourceKey, tree) {
       const keyMaps = getCachesForTree(tree);
 
       // First check to see if we've already computed an result key for this
@@ -62,7 +62,7 @@ export default function createCachedKeysTransform(keyMap, deep = false) {
         return keyMaps.sourceKeyToResultKey.get(sourceKey);
       }
 
-      const resultKey = await keyMap(sourceKey, tree);
+      const resultKey = await keyFn(sourceKey, tree);
 
       // Cache the mappings from source key <-> result key for next time.
       keyMaps.sourceKeyToResultKey.set(sourceKey, resultKey);

package/src/transforms/groupBy.js

@@ -11,7 +11,8 @@ export default function createGroupByTransform(groupKeyFn) {
   /**
    * @type {import("../../index.ts").TreeTransform}
    */
-  return async function groupByTransform(tree) {
+  return async function groupByTransform(treelike) {
+    const tree = Tree.from(treelike);
     const result = {};
     for (const key of await tree.keys()) {
       const value = await tree.get(key);

package/src/transforms/{keyMapsForExtensions.js → keyFunctionsForExtensions.js}

@@ -2,14 +2,14 @@
  * Given a source resultExtension and a result resultExtension, return a pair of key
  * functions that map between them.
  *
- * The resulting `inverseKeyMap` and `keyMap` functions are compatible with those
+ * 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
  */
-export default function keyMapsForExtensions({
+export default function keyFunctionsForExtensions({
   resultExtension,
   sourceExtension,
 }) {
@@ -18,12 +18,12 @@ export default function keyMapsForExtensions({
   }
 
   return {
-    async inverseKeyMap(resultKey, tree) {
+    async inverseKey(resultKey, tree) {
       const basename = matchExtension(resultKey, resultExtension);
       return basename ? `${basename}${dotPrefix(sourceExtension)}` : undefined;
     },
 
-    async keyMap(sourceKey, tree) {
+    async key(sourceKey, tree) {
       const basename = matchExtension(sourceKey, sourceExtension);
       return basename ? `${basename}${dotPrefix(resultExtension)}` : undefined;
     },

package/src/transforms/map.js

@@ -6,63 +6,64 @@ import * as Tree from "../Tree.js";
  * @typedef {import("../../index.ts").KeyFn} KeyFn
  * @typedef {import("../../index.ts").ValueKeyFn} ValueKeyFn
  *
- * @param {ValueKeyFn|{ deep?: boolean, description?: string, needsSourceValue?: boolean, inverseKeyMap?: KeyFn, keyMap?: KeyFn, valueMap?: ValueKeyFn }} options
+ * @param {ValueKeyFn|{ deep?: boolean, description?: string, needsSourceValue?: boolean, inverseKey?: KeyFn, key?: KeyFn, value?: ValueKeyFn }} options
  */
-export default function createMapTransform(options) {
+export default function createMapTransform(options = {}) {
   let deep;
   let description;
-  let inverseKeyMap;
-  let keyMap;
+  let inverseKeyFn;
+  let keyFn;
   let needsSourceValue;
-  let valueMap;
+  let valueFn;
   if (typeof options === "function") {
-    // Take the single function argument as the valueMap
-    valueMap = options;
+    // Take the single function argument as the valueFn
+    valueFn = options;
   } else {
     deep = options.deep;
     description = options.description;
-    inverseKeyMap = options.inverseKeyMap;
-    keyMap = options.keyMap;
+    inverseKeyFn = options.inverseKey;
+    keyFn = options.key;
     needsSourceValue = options.needsSourceValue;
-    valueMap = options.valueMap;
+    valueFn = options.value;
   }
 
   deep ??= false;
   description ??= "key/value map";
   // @ts-ignore
-  inverseKeyMap ??= valueMap?.inverseKeyMap;
+  inverseKeyFn ??= valueFn?.inverseKey;
   // @ts-ignore
-  keyMap ??= valueMap?.keyMap;
+  keyFn ??= valueFn?.key;
   needsSourceValue ??= true;
 
-  if ((keyMap && !inverseKeyMap) || (!keyMap && inverseKeyMap)) {
+  if ((keyFn && !inverseKeyFn) || (!keyFn && inverseKeyFn)) {
     throw new TypeError(
-      `map: You must specify both keyMap and inverseKeyMap, or neither.`
+      `map: You must specify both key and inverseKey functions, or neither.`
     );
   }
 
   /**
    * @type {import("../../index.ts").TreeTransform}
    */
-  return function map(tree) {
+  return function map(treelike) {
+    const tree = Tree.from(treelike);
     // The transformed tree is actually an extension of the original tree's
     // prototype chain. This allows the transformed tree to inherit any
-    // properties/methods that do not need to be specified. For example, the
-    // `parent` of the transformed tree is the original tree's parent.
+    // properties/methods. For example, the `parent` of the transformed tree is
+    // the original tree's parent.
     const transformed = Object.create(tree);
 
     transformed.description = description;
 
-    if (keyMap || valueMap) {
+    if (keyFn || valueFn) {
       transformed.get = async (resultKey) => {
         // Step 1: Map the result key to the source key.
         const isSubtree = deep && (await Tree.isKeyForSubtree(tree, resultKey));
         const sourceKey =
-          !isSubtree && inverseKeyMap
-            ? await inverseKeyMap(resultKey, tree)
+          !isSubtree && inverseKeyFn
+            ? await inverseKeyFn(resultKey, tree)
             : resultKey;
 
-        if (!sourceKey) {
+        if (sourceKey == null) {
           // No source key means no value.
           return undefined;
         }
@@ -85,9 +86,9 @@ export default function createMapTransform(options) {
         } else if (deep && Tree.isAsyncTree(sourceValue)) {
           // Map a subtree.
           resultValue = map(sourceValue);
-        } else if (valueMap) {
+        } else if (valueFn) {
           // Map a single value.
-          resultValue = await valueMap(sourceValue, sourceKey, tree);
+          resultValue = await valueFn(sourceValue, sourceKey, tree);
         } else {
           // Return source value as is.
           resultValue = sourceValue;
@@ -97,9 +98,9 @@ export default function createMapTransform(options) {
       };
     }
 
-    if (keyMap) {
+    if (keyFn) {
       transformed.keys = async () => {
-        // Apply the keyMap to source keys for leaf values (not subtrees).
+        // Apply the keyFn to source keys for leaf values (not subtrees).
         const sourceKeys = Array.from(await tree.keys());
         const mapped = await Promise.all(
           sourceKeys.map(async (sourceKey) => {
@@ -107,12 +108,12 @@ export default function createMapTransform(options) {
             if (deep && (await Tree.isKeyForSubtree(tree, sourceKey))) {
               resultKey = sourceKey;
             } else {
-              resultKey = await keyMap(sourceKey, tree);
+              resultKey = await keyFn(sourceKey, tree);
             }
             return resultKey;
           })
         );
-        // Filter out any cases where the keyMap returned undefined.
+        // Filter out any cases where the keyFn returned undefined.
         const resultKeys = mapped.filter((key) => key !== undefined);
         return resultKeys;
       };

package/src/transforms/regExpKeys.js

@@ -10,7 +10,8 @@ import * as Tree from "../Tree.js";
  *
  * @type {import("../../index.ts").TreeTransform}
  */
-export default async function regExpKeys(tree) {
+export default async function regExpKeys(treelike) {
+  const tree = Tree.from(treelike);
   const map = new Map();
 
   // We build the output tree first so that we can refer to it when setting

package/src/transforms/sort.js

@@ -1,3 +1,5 @@
+import * as Tree from "../Tree.js";
+
 /**
  * Return a transform function that sorts a tree's keys.
  *
@@ -10,7 +12,8 @@ export default function createSortTransform(compareFn) {
   /**
    * @type {import("../../index.ts").TreeTransform}
    */
-  return function sortTransform(tree) {
+  return function sortTransform(treelike) {
+    const tree = Tree.from(treelike);
     const transform = Object.create(tree);
     transform.keys = async () => {
       const keys = Array.from(await tree.keys());

package/src/transforms/sortBy.js

@@ -1,3 +1,5 @@
+import * as Tree from "../Tree.js";
+
 /**
  * Return a transform function that sorts a tree's keys.
  *
@@ -11,7 +13,8 @@ export default function createSortByTransform(sortKeyFn) {
   /**
    * @type {import("../../index.ts").TreeTransform}
    */
-  return function sortByTransform(tree) {
+  return function sortByTransform(treelike) {
+    const tree = Tree.from(treelike);
     const transform = Object.create(tree);
     transform.keys = async () => {
       const keysAndSortKeys = [];
@@ -22,7 +25,8 @@ export default function createSortByTransform(sortKeyFn) {
       keysAndSortKeys.sort((a, b) =>
         a.sortKey < b.sortKey ? -1 : a.sortKey > b.sortKey ? 1 : 0
       );
-      return keysAndSortKeys.map(({ key }) => key);
+      const sortedKeys = keysAndSortKeys.map(({ key }) => key);
+      return sortedKeys;
     };
     return transform;
   };

package/test/transforms/cachedKeyMaps.test.js

@@ -1,9 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import ObjectTree from "../../src/ObjectTree.js";
-import cachedKeyMaps from "../../src/transforms/cachedKeyMaps.js";
+import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
 
-describe("cachedKeyMaps", () => {
+describe("cachedKeyFunctions", () => {
   test("maps keys with caching", async () => {
     const tree = new ObjectTree({
       a: "letter a",
@@ -16,26 +16,26 @@ describe("cachedKeyMaps", () => {
       return `_${sourceKey}`;
     };
 
-    const { inverseKeyMap, keyMap } = cachedKeyMaps(underscoreKeys);
+    const { inverseKey, key } = cachedKeyFunctions(underscoreKeys);
 
-    assert.equal(await inverseKeyMap("_a", tree), "a"); // Cache miss
+    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
     assert.equal(callCount, 1);
-    assert.equal(await inverseKeyMap("_a", tree), "a");
+    assert.equal(await inverseKey("_a", tree), "a");
     assert.equal(callCount, 1);
-    assert.equal(await inverseKeyMap("_b", tree), "b"); // Cache miss
+    assert.equal(await inverseKey("_b", tree), "b"); // Cache miss
     assert.equal(callCount, 2);
 
-    assert.equal(await keyMap("a", tree), "_a");
-    assert.equal(await keyMap("a", tree), "_a");
-    assert.equal(await keyMap("b", tree), "_b");
+    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 inverseKeyMap("_c", tree), undefined);
+    assert.equal(await inverseKey("_c", tree), undefined);
     // But key mapping is still possible.
-    assert.equal(await keyMap("c", tree), "_c");
+    assert.equal(await key("c", tree), "_c");
     // And now we have a cache hit.
-    assert.equal(await inverseKeyMap("_c", tree), "c");
+    assert.equal(await inverseKey("_c", tree), "c");
     assert.equal(callCount, 3);
   });
 });

package/test/transforms/keyMapsForExtensions.test.js

@@ -2,29 +2,29 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import ObjectTree from "../../src/ObjectTree.js";
 import * as Tree from "../../src/Tree.js";
-import keyMapsForExtensions from "../../src/transforms/keyMapsForExtensions.js";
+import keyFunctionsForExtensions from "../../src/transforms/keyFunctionsForExtensions.js";
 import map from "../../src/transforms/map.js";
 
 describe("keyMapsForExtensions", () => {
   test("returns key functions that pass a matching key through", async () => {
-    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+    const { inverseKey, key } = keyFunctionsForExtensions({
       sourceExtension: "txt",
     });
-    assert.equal(await inverseKeyMap("file.txt"), "file.txt");
-    assert.equal(await keyMap("file.txt"), "file.txt");
-    assert.equal(await inverseKeyMap("file.foo"), undefined);
-    assert.equal(await keyMap("file.foo"), undefined);
+    assert.equal(await inverseKey("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 { inverseKeyMap, keyMap } = keyMapsForExtensions({
+    const { inverseKey, key } = keyFunctionsForExtensions({
       resultExtension: "html",
       sourceExtension: "md",
     });
-    assert.equal(await inverseKeyMap("file.html"), "file.md");
-    assert.equal(await keyMap("file.md"), "file.html");
-    assert.equal(await inverseKeyMap("file.foo"), undefined);
-    assert.equal(await keyMap("file.foo"), undefined);
+    assert.equal(await inverseKey("file.html"), "file.md");
+    assert.equal(await key("file.md"), "file.html");
+    assert.equal(await inverseKey("file.foo"), undefined);
+    assert.equal(await key("file.foo"), undefined);
   });
 
   test("works with map to handle keys that end in a given resultExtension", async () => {
@@ -33,13 +33,13 @@ describe("keyMapsForExtensions", () => {
       file2: "won't be mapped",
       "file3.foo": "won't be mapped",
     });
-    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+    const { inverseKey, key } = keyFunctionsForExtensions({
       sourceExtension: "txt",
     });
     const transform = map({
-      inverseKeyMap,
-      keyMap,
-      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+      inverseKey,
+      key,
+      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const fixture = transform(files);
     assert.deepEqual(await Tree.plain(fixture), {
@@ -53,14 +53,14 @@ describe("keyMapsForExtensions", () => {
       file2: "won't be mapped",
       "file3.foo": "won't be mapped",
     });
-    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+    const { inverseKey, key } = keyFunctionsForExtensions({
       resultExtension: "upper",
       sourceExtension: "txt",
     });
     const transform = map({
-      inverseKeyMap,
-      keyMap,
-      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+      inverseKey,
+      key,
+      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const fixture = transform(files);
     assert.deepEqual(await Tree.plain(fixture), {

package/test/transforms/map.test.js

@@ -1,18 +1,18 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { ObjectTree } from "../../main.js";
 import DeepObjectTree from "../../src/DeepObjectTree.js";
 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";
 
 describe("map", () => {
-  test("returns identity graph if no keyMap or valueMap", async () => {
-    const tree = new ObjectTree({
+  test("returns identity graph if no key or value", async () => {
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
-    const mapped = map({})(tree);
+    };
+    const mapped = map()(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       a: "letter a",
       b: "letter b",
@@ -26,7 +26,7 @@ describe("map", () => {
       c: undefined, // Won't be mapped
     });
     const uppercaseValues = map({
-      valueMap: (sourceValue, sourceKey, innerTree) => {
+      value: (sourceValue, sourceKey, innerTree) => {
         assert(sourceKey === "a" || sourceKey === "b");
         assert.equal(innerTree, tree);
         return sourceValue.toUpperCase();
@@ -41,13 +41,12 @@ describe("map", () => {
   });
 
   test("interprets a single function argument as the value function", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
-    const uppercaseValues = map((sourceValue, sourceKey, innerTree) => {
+    };
+    const uppercaseValues = map((sourceValue, sourceKey, tree) => {
       assert(sourceKey === "a" || sourceKey === "b");
-      assert.equal(innerTree, tree);
       return sourceValue.toUpperCase();
     });
     const mapped = uppercaseValues(tree);
@@ -57,14 +56,14 @@ describe("map", () => {
     });
   });
 
-  test("maps keys using keyMap and inverseKeyMap", async () => {
-    const tree = new ObjectTree({
+  test("maps keys using key and inverseKey", async () => {
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
+    };
     const doubleKeys = map({
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -74,15 +73,14 @@ describe("map", () => {
   });
 
   test("maps keys and values", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
+    };
     const doubleKeysUppercaseValues = map({
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
-      valueMap: async (sourceValue, sourceKey, tree) =>
-        sourceValue.toUpperCase(),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = doubleKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -92,16 +90,16 @@ describe("map", () => {
   });
 
   test("a shallow map is applied to async subtrees too", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       a: "letter a",
       more: {
         b: "letter b",
       },
-    });
+    };
     const doubleKeys = map({
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
-      valueMap: async (sourceValue, sourceKey, tree) => sourceKey,
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -110,14 +108,14 @@ describe("map", () => {
     });
   });
 
-  test("valueMap can provide a default keyMap and inverseKeyMap", async () => {
+  test("value can provide a default key and inverse key functions", async () => {
     const uppercase = (s) => s.toUpperCase();
-    uppercase.keyMap = (sourceKey) => `_${sourceKey}`;
-    uppercase.inverseKeyMap = (resultKey) => resultKey.slice(1);
-    const tree = new ObjectTree({
+    uppercase.key = (sourceKey) => `_${sourceKey}`;
+    uppercase.inverseKey = (resultKey) => resultKey.slice(1);
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
+    };
     const mapped = map(uppercase)(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
@@ -134,7 +132,7 @@ describe("map", () => {
     });
     const uppercaseValues = map({
       deep: true,
-      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = uppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -154,8 +152,8 @@ describe("map", () => {
     });
     const doubleKeys = map({
       deep: true,
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -175,10 +173,9 @@ describe("map", () => {
     });
     const doubleKeysUppercaseValues = map({
       deep: true,
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
-      valueMap: async (sourceValue, sourceKey, tree) =>
-        sourceValue.toUpperCase(),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = doubleKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -196,7 +193,7 @@ describe("map", () => {
     }, ["a", "b", "c"]);
     const mapped = map({
       needsSourceValue: false,
-      valueMap: () => "X",
+      value: () => "X",
     })(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       a: "X",