@weborigami/async-tree 0.5.5 → 0.5.6

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "dependencies": {
-    "@weborigami/types": "0.5.5"
+    "@weborigami/types": "0.5.6"
   },
   "devDependencies": {
     "@types/node": "24.3.0",

package/shared.js

@@ -12,6 +12,7 @@ export { default as ObjectTree } from "./src/drivers/ObjectTree.js";
 export { default as SetTree } from "./src/drivers/SetTree.js";
 export { default as SiteTree } from "./src/drivers/SiteTree.js";
 export * as jsonKeys from "./src/jsonKeys.js";
+export { default as scope } from "./src/operations/scope.js";
 export * as symbols from "./src/symbols.js";
 export * as trailingSlash from "./src/trailingSlash.js";
 export { default as TraverseError } from "./src/TraverseError.js";

package/src/Tree.js

@@ -8,7 +8,6 @@ export { default as addNextPrevious } from "./operations/addNextPrevious.js";
 export { default as assign } from "./operations/assign.js";
 export { default as cache } from "./operations/cache.js";
 export { default as clear } from "./operations/clear.js";
-export { default as concat } from "./operations/concat.js";
 export { default as deepMap } from "./operations/deepMap.js";
 export { default as deepMerge } from "./operations/deepMerge.js";
 export { default as deepReverse } from "./operations/deepReverse.js";
@@ -16,16 +15,15 @@ export { default as deepTake } from "./operations/deepTake.js";
 export { default as deepText } from "./operations/deepText.js";
 export { default as deepValues } from "./operations/deepValues.js";
 export { default as deepValuesIterator } from "./operations/deepValuesIterator.js";
-export { default as defineds } from "./operations/defineds.js";
 export { default as delete } from "./operations/delete.js";
 export { default as entries } from "./operations/entries.js";
 export { default as filter } from "./operations/filter.js";
 export { default as first } from "./operations/first.js";
 export { default as forEach } from "./operations/forEach.js";
 export { default as from } from "./operations/from.js";
-export { default as fromFn } from "./operations/fromFn.js";
 export { default as globKeys } from "./operations/globKeys.js";
 export { default as group } from "./operations/group.js";
+export { default as groupBy } from "./operations/groupBy.js";
 export { default as has } from "./operations/has.js";
 export { default as indent } from "./operations/indent.js";
 export { default as inners } from "./operations/inners.js";
@@ -51,7 +49,6 @@ export { default as regExpKeys } from "./operations/regExpKeys.js";
 export { default as reverse } from "./operations/reverse.js";
 export { default as root } from "./operations/root.js";
 export { default as scope } from "./operations/scope.js";
-export { default as setDeep } from "./operations/setDeep.js";
 export { default as shuffle } from "./operations/shuffle.js";
 export { default as sort } from "./operations/sort.js";
 export { default as take } from "./operations/take.js";

package/src/drivers/FunctionTree.js

@@ -27,11 +27,11 @@ export default class FunctionTree {
       this.fn.length <= 1
         ? // Function takes no arguments, one argument, or a variable number of
           // arguments: invoke it.
-          await this.fn.call(this.parent, key)
+          await this.fn(key)
         : // Bind the key to the first parameter. Subsequent get calls will
           // eventually bind all parameters until only one remains. At that point,
           // the above condition will apply and the function will be invoked.
-          Reflect.construct(this.constructor, [this.fn.bind(this.parent, key)]);
+          Reflect.construct(this.constructor, [this.fn.bind(null, key)]);
     setParent(value, this);
     return value;
   }

package/src/drivers/ObjectTree.js

@@ -57,12 +57,9 @@ export default class ObjectTree {
 
     setParent(value, this);
 
-    // Is value an instance method? The first clause sees if the object is a
-    // constructor, in which case the method is likely a static method.
+    // Is value an instance method?
     const isInstanceMethod =
-      !(this.object instanceof Function) &&
-      value instanceof Function &&
-      !Object.hasOwn(this.object, key);
+      value instanceof Function && !Object.hasOwn(this.object, key);
     if (isInstanceMethod) {
       // Bind it to the object
       value = value.bind(this.object);

package/src/operations/group.js

@@ -1,51 +1,6 @@
-import ObjectTree from "../drivers/ObjectTree.js";
-import getTreeArgument from "../utilities/getTreeArgument.js";
-import from from "./from.js";
-import isTreelike from "./isTreelike.js";
-import values from "./values.js";
+import groupBy from "./groupBy.js";
 
-/**
- * Given a function that returns a grouping key for a value, returns a transform
- * that applies that grouping function to a tree.
- *
- * @param {import("../../index.ts").Treelike} treelike
- * @param {import("../../index.ts").ValueKeyFn} groupKeyFn
- */
 export default async function group(treelike, groupKeyFn) {
-  const tree = await getTreeArgument(treelike, "group");
-
-  const keys = Array.from(await tree.keys());
-
-  // Are all the keys integers?
-  const isArray = keys.every((key) => !Number.isNaN(parseInt(key)));
-
-  const result = {};
-  for (const key of await tree.keys()) {
-    const value = await tree.get(key);
-
-    // Get the groups for this value.
-    let groups = await groupKeyFn(value, key, tree);
-    if (!groups) {
-      continue;
-    }
-
-    if (!isTreelike(groups)) {
-      // A single value was returned
-      groups = [groups];
-    }
-    groups = from(groups);
-
-    // Add the value to each group.
-    for (const group of await values(groups)) {
-      if (isArray) {
-        result[group] ??= [];
-        result[group].push(value);
-      } else {
-        result[group] ??= {};
-        result[group][key] = value;
-      }
-    }
-  }
-
-  return new ObjectTree(result);
+  console.warn("Tree.group() is deprecated. Use Tree.groupBy() instead.");
+  return groupBy(treelike, groupKeyFn);
 }

package/src/operations/groupBy.js

@@ -0,0 +1,51 @@
+import ObjectTree from "../drivers/ObjectTree.js";
+import getTreeArgument from "../utilities/getTreeArgument.js";
+import from from "./from.js";
+import isTreelike from "./isTreelike.js";
+import values from "./values.js";
+
+/**
+ * Given a function that returns a grouping key for a value, returns a transform
+ * that applies that grouping function to a tree.
+ *
+ * @param {import("../../index.ts").Treelike} treelike
+ * @param {import("../../index.ts").ValueKeyFn} groupKeyFn
+ */
+export default async function groupBy(treelike, groupKeyFn) {
+  const tree = await getTreeArgument(treelike, "groupBy");
+
+  const keys = Array.from(await tree.keys());
+
+  // Are all the keys integers?
+  const isArray = keys.every((key) => !Number.isNaN(parseInt(key)));
+
+  const result = {};
+  for (const key of await tree.keys()) {
+    const value = await tree.get(key);
+
+    // Get the groups for this value.
+    let groups = await groupKeyFn(value, key, tree);
+    if (!groups) {
+      continue;
+    }
+
+    if (!isTreelike(groups)) {
+      // A single value was returned
+      groups = [groups];
+    }
+    groups = from(groups);
+
+    // Add the value to each group.
+    for (const group of await values(groups)) {
+      if (isArray) {
+        result[group] ??= [];
+        result[group].push(value);
+      } else {
+        result[group] ??= {};
+        result[group][key] = value;
+      }
+    }
+  }
+
+  return new ObjectTree(result);
+}

package/src/operations/map.js

@@ -186,6 +186,11 @@ function validateOptions(options) {
     throw error;
   }
 
+  if (extension && !options._noExtensionWarning) {
+    console.warn(
+      `map: The 'extension' option for Tree.map() is deprecated and will be removed in a future release. Use Tree.mapExtension() instead.`
+    );
+  }
   if (extension && (keyFn || inverseKeyFn)) {
     throw new TypeError(
       `map: You can't specify extensions and also a key or inverseKey function`

package/src/operations/mapExtension.js

@@ -1,27 +1,78 @@
-import getTreeArgument from "../utilities/getTreeArgument.js";
 import isPlainObject from "../utilities/isPlainObject.js";
 import map from "./map.js";
 
 /**
- * Shorthand for calling `map` with the `deep: true` option.
- *
  * @typedef {import("../../index.ts").TreeMapExtensionOptions} TreeMapExtensionOptions
  * @typedef {import("../../index.ts").Treelike} Treelike
  * @typedef {import("../../index.ts").ValueKeyFn} ValueKeyFn
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
+ */
+
+/**
+ * @overload
+ * @param {Treelike} treelike
+ * @param {string} extension
+ */
+
+/**
+ * @overload
+ * @param {Treelike} treelike
+ * @param {TreeMapExtensionOptions} options
+ */
+
+/**
+ * @overload
+ * @param {Treelike} treelike
+ * @param {string} extension
+ * @param {ValueKeyFn} fn
+ */
+
+/**
+ * @overload
  * @param {Treelike} treelike
  * @param {string} extension
- * @param {ValueKeyFn|TreeMapExtensionOptions} options
+ * @param {TreeMapExtensionOptions} options
+ */
+
+/**
+ * Shorthand for calling `map` with the `deep: true` option.
+ *
+ * @param {Treelike} treelike
+ * @param {string|TreeMapExtensionOptions} arg2
+ * @param {ValueKeyFn|TreeMapExtensionOptions} [arg3]
  * @returns {Promise<AsyncTree>}
  */
-export default async function mapExtension(treelike, extension, options) {
-  const tree = await getTreeArgument(treelike, "mapExtension");
-  const withExtension = isPlainObject(options)
-    ? // Dictionary
-      { ...options, extension }
-    : // Function
-      { extension, value: options };
+export default async function mapExtension(treelike, arg2, arg3) {
+  /** @type {TreeMapExtensionOptions} */
+  // @ts-ignore
+  let options = { _noExtensionWarning: true };
+  if (arg3 === undefined) {
+    if (typeof arg2 === "string") {
+      options.extension = arg2;
+    } else if (isPlainObject(arg2)) {
+      Object.assign(options, arg2);
+    } else {
+      throw new TypeError(
+        "mapExtension: Expected a string or options object for the second argument."
+      );
+    }
+  } else {
+    if (typeof arg2 !== "string") {
+      throw new TypeError(
+        "mapExtension: Expected a string for the second argument."
+      );
+    }
+    options.extension = arg2;
+    if (typeof arg3 === "function") {
+      options.value = arg3;
+    } else if (isPlainObject(arg3)) {
+      Object.assign(options, arg3);
+    } else {
+      throw new TypeError(
+        "mapExtension: Expected a function or options object for the third argument."
+      );
+    }
+  }
 
-  return map(tree, withExtension);
+  return map(treelike, options);
 }

package/src/operations/match.js

@@ -15,7 +15,7 @@ import isAsyncTree from "./isAsyncTree.js";
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("../../index.ts").Treelike} Treelike
- * @typedef {import("@weborigami/async-tree").Invocable} Invocable
+ * @typedef {import("../../index.ts").Invocable} Invocable
  *
  * @param {string|RegExp} pattern
  * @param {Invocable} resultFn

package/src/operations/traverse.js

@@ -6,7 +6,6 @@ import traverseOrThrow from "./traverseOrThrow.js";
  *
  * @typedef {import("../../index.ts").Treelike} Treelike
  *
- * @this {any}
  * @param {Treelike} treelike
  * @param {...any} keys
  */
@@ -14,7 +13,7 @@ export default async function traverse(treelike, ...keys) {
   try {
     // Await the result here so that, if the path doesn't exist, the catch
     // block below will catch the exception.
-    return await traverseOrThrow.call(this, treelike, ...keys);
+    return await traverseOrThrow(treelike, ...keys);
   } catch (/** @type {any} */ error) {
     if (error instanceof TraverseError) {
       return undefined;

package/src/operations/traverseOrThrow.js

@@ -9,7 +9,6 @@ import from from "./from.js";
  * @typedef {import("../../index.ts").Treelike} Treelike
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @this {any}
  * @param {Treelike} treelike
  * @param  {...any} keys
  */
@@ -19,10 +18,6 @@ export default async function traverseOrThrow(treelike, ...keys) {
   let value = treelike;
   let position = 0;
 
-  // If traversal operation was called with a `this` context, use that as the
-  // target for function calls.
-  const target = this;
-
   // Process all the keys.
   const remainingKeys = keys.slice();
   let key;
@@ -47,7 +42,7 @@ export default async function traverseOrThrow(treelike, ...keys) {
       let fnKeyCount = Math.max(fn.length, 1);
       const args = remainingKeys.splice(0, fnKeyCount);
       key = null;
-      value = await fn.call(target, ...args);
+      value = await fn(...args);
     } else {
       // Cast value to a tree.
       const tree = from(value);

package/src/utilities/toFunction.js

@@ -17,7 +17,6 @@ export default function toFunction(obj) {
   } else if (isUnpackable(obj)) {
     // Extract the contents of the object and convert that to a function.
     let fnPromise;
-    /** @this {any} */
     return async function (...args) {
       if (!fnPromise) {
         // unpack() may return a function or a promise for a function; normalize
@@ -28,7 +27,7 @@ export default function toFunction(obj) {
         fnPromise = unpackPromise.then((content) => toFunction(content));
       }
       const fn = await fnPromise;
-      return fn.call(this, ...args);
+      return fn(...args);
     };
   } else if (isTreelike(obj)) {
     // Return a function that invokes the tree's getter.

package/test/operations/deepReverse.test.js

@@ -12,7 +12,7 @@ describe("deepReverse", () => {
         d: 3,
       },
     };
-    const reversed = await deepReverse.call(null, tree);
+    const reversed = await deepReverse(tree);
     assert.deepEqual(await Tree.plain(reversed), {
       b: {
         d: 3,

package/test/operations/{group.test.js → groupBy.test.js}

@@ -1,9 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { Tree } from "../../src/internal.js";
-import group from "../../src/operations/group.js";
+import groupBy from "../../src/operations/groupBy.js";
 
-describe("group transform", () => {
+describe("groupBy transform", () => {
   test("groups an array using a group key function", async () => {
     const fonts = [
       { name: "Aboreto", tags: ["Sans Serif"] },
@@ -12,7 +12,7 @@ describe("group transform", () => {
       { name: "Work Sans", tags: ["Grotesque", "Sans Serif"] },
     ];
     const tree = Tree.from(fonts);
-    const grouped = await group(tree, (value, key, tree) => value.tags);
+    const grouped = await groupBy(tree, (value, key, tree) => value.tags);
     assert.deepEqual(await Tree.plain(grouped), {
       Geometric: [{ name: "Albert Sans", tags: ["Geometric", "Sans Serif"] }],
       Grotesque: [{ name: "Work Sans", tags: ["Grotesque", "Sans Serif"] }],
@@ -33,7 +33,7 @@ describe("group transform", () => {
       "Work Sans": { tags: ["Grotesque", "Sans Serif"] },
     };
     const tree = Tree.from(fonts);
-    const grouped = await group(tree, (value, key, tree) => value.tags);
+    const grouped = await groupBy(tree, (value, key, tree) => value.tags);
     assert.deepEqual(await Tree.plain(grouped), {
       Geometric: {
         "Albert Sans": { tags: ["Geometric", "Sans Serif"] },

package/test/operations/map.test.js

@@ -208,56 +208,6 @@ describe("map", () => {
       C: "letter c",
     });
   });
-
-  test("can add an extension to a key", async () => {
-    const treelike = {
-      "file0.txt": 1,
-      file1: 2,
-      file2: 3,
-    };
-    const fixture = await map(treelike, {
-      extension: "->.data",
-    });
-    assert.deepEqual(await Tree.plain(fixture), {
-      "file0.txt.data": 1,
-      "file1.data": 2,
-      "file2.data": 3,
-    });
-  });
-
-  test("can change a key's extension", async () => {
-    const treelike = {
-      "file1.lower": "will be mapped",
-      file2: "won't be mapped",
-      "file3.foo": "won't be mapped",
-    };
-    const fixture = await map(treelike, {
-      extension: ".lower->.upper",
-      value: (sourceValue) => sourceValue.toUpperCase(),
-    });
-    assert.deepEqual(await Tree.plain(fixture), {
-      "file1.upper": "WILL BE MAPPED",
-    });
-  });
-
-  test("can manipulate extensions deeply", async () => {
-    const treelike = {
-      "file1.txt": 1,
-      more: {
-        "file2.txt": 2,
-      },
-    };
-    const fixture = await map(treelike, {
-      deep: true,
-      extension: ".txt->",
-    });
-    assert.deepEqual(await Tree.plain(fixture), {
-      file1: 1,
-      more: {
-        file2: 2,
-      },
-    });
-  });
 });
 
 function addUnderscore(value, key) {

package/test/operations/mapExtension.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import mapExtension from "../../src/operations/mapExtension.js";
+import plain from "../../src/operations/plain.js";
+
+describe("mapExtension", () => {
+  test("can add an extension to a key", async () => {
+    const treelike = {
+      "file0.txt": 1,
+      file1: 2,
+      file2: 3,
+    };
+    const fixture = await mapExtension(treelike, "->.data");
+    assert.deepEqual(await plain(fixture), {
+      "file0.txt.data": 1,
+      "file1.data": 2,
+      "file2.data": 3,
+    });
+  });
+
+  test("can change a key's extension", async () => {
+    const treelike = {
+      "file1.lower": "will be mapped",
+      file2: "won't be mapped",
+      "file3.foo": "won't be mapped",
+    };
+    const fixture = await mapExtension(treelike, {
+      extension: ".lower->.upper",
+      value: (sourceValue) => sourceValue.toUpperCase(),
+    });
+    assert.deepEqual(await plain(fixture), {
+      "file1.upper": "WILL BE MAPPED",
+    });
+  });
+
+  test("can manipulate extensions deeply", async () => {
+    const treelike = {
+      "file1.txt": 1,
+      more: {
+        "file2.txt": 2,
+      },
+    };
+    const fixture = await mapExtension(treelike, ".txt->", {
+      deep: true,
+    });
+    assert.deepEqual(await plain(fixture), {
+      file1: 1,
+      more: {
+        file2: 2,
+      },
+    });
+  });
+});

package/test/operations/paginate.test.js

@@ -12,7 +12,7 @@ describe("paginate", () => {
       d: 4,
       e: 5,
     };
-    const paginated = await paginate.call(null, treelike, 2);
+    const paginated = await paginate(treelike, 2);
     const plain = await Tree.plain(paginated);
     assert.deepEqual(await plain, {
       1: {

package/test/operations/reverse.test.js

@@ -10,7 +10,7 @@ describe("reverse", () => {
       b: "B",
       c: "C",
     };
-    const reversed = await reverse.call(null, tree);
+    const reversed = await reverse(tree);
     // @ts-ignore
     assert.deepEqual(Array.from(await reversed.keys()), ["c", "b", "a"]);
     // @ts-ignore

package/src/operations/concat.js

@@ -1,17 +0,0 @@
-import deepText from "./deepText.js";
-import from from "./from.js";
-
-/**
- * Concatenate the text content of objects or trees.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
- * @param {any[]} args
- */
-export default async function concat(...args) {
-  console.warn(
-    "Warning: the Tree.concat function is deprecated, use Tree.deepText instead."
-  );
-  const tree = from(args);
-  return deepText(tree);
-}

package/src/operations/defineds.js

@@ -1,32 +0,0 @@
-import getTreeArgument from "../utilities/getTreeArgument.js";
-import mapReduce from "./mapReduce.js";
-
-/**
- * Return only the defined (not `undefined`) values in the deep tree.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Treelike} Treelike
- *
- * @param {Treelike} treelike
- */
-export default async function defineds(treelike) {
-  console.warn(
-    "Warning: Tree.defineds is deprecated. If you have a use for it, please let us know."
-  );
-  const tree = await getTreeArgument(treelike, "defineds", { deep: true });
-
-  const result = await mapReduce(tree, null, async (values, keys) => {
-    const object = {};
-    let someValuesExist = false;
-    for (let i = 0; i < keys.length; i++) {
-      const value = values[i];
-      if (value != null) {
-        someValuesExist = true;
-        object[keys[i]] = values[i];
-      }
-    }
-    return someValuesExist ? object : null;
-  });
-
-  return result;
-}

package/src/operations/fromFn.js

@@ -1,26 +0,0 @@
-import FunctionTree from "../drivers/FunctionTree.js";
-import isUnpackable from "../utilities/isUnpackable.js";
-import toFunction from "../utilities/toFunction.js";
-
-/**
- * Create a tree from a function and a set of keys.
- *
- * @typedef {import("@weborigami/async-tree").Invocable} Invocable
- *
- * @param {Invocable} invocable
- */
-export default async function fromFn(invocable, keys = []) {
-  console.warn("Tree.fromFn is deprecated, use Tree.withKeys instead.");
-  if (invocable === undefined) {
-    throw new Error(
-      "Tree.fromFn: the first argument must be a function or a tree."
-    );
-  }
-  const fn = toFunction(invocable);
-  if (isUnpackable(keys)) {
-    keys = await keys.unpack();
-  }
-  // @ts-ignore
-  const tree = new FunctionTree(fn, keys);
-  return tree;
-}

package/src/operations/remove.js

@@ -1,14 +0,0 @@
-import { default as del } from "./delete.js";
-
-/**
- * Removes the value for the given key from the specific node of the tree.
- *
- * @typedef {import("@weborigami/types").AsyncMutableTree} AsyncMutableTree
- *
- * @param {AsyncMutableTree} tree
- * @param {any} key
- */
-export default async function remove(tree, key) {
-  console.warn("`Tree.remove` is deprecated. Use `Tree.delete` instead.");
-  return del(tree, key);
-}

package/src/operations/setDeep.js

@@ -1,50 +0,0 @@
-import from from "./from.js";
-import isAsyncTree from "./isAsyncTree.js";
-
-/**
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @param {Treelike} target
- * @param {Treelike} source
- */
-export default async function setDeep(target, source) {
-  console.warn("Tree.setDeep is deprecated, use Tree.assign instead.");
-  const targetTree = from(target);
-  const sourceTree = from(source);
-  await applyUpdates(sourceTree, targetTree);
-}
-
-// Apply all updates from the source to the target.
-async function applyUpdates(source, target) {
-  // Fire off requests to update all keys, then wait for all of them to finish.
-  const promises = [];
-  for (const key of await source.keys()) {
-    const updateKeyPromise = applyUpdateForKey(source, target, key);
-    promises.push(updateKeyPromise);
-  }
-  await Promise.all(promises);
-
-  // HACK: Transforms like KeysTransform that maintain caches will need to
-  // recalculate things now that updates have been applied. This should be an
-  // automatic part of calling set() -- but triggering those changes inside
-  // set() produces cases where set() and get() calls can be interleaved. The
-  // atomicity of set() needs to be reconsidered. For now, we work around the
-  // problem by triggering `onChange` after the updates have been applied.
-  target.onChange?.();
-}
-
-// Copy the value for the given key from the source to the target.
-async function applyUpdateForKey(source, target, key) {
-  const sourceValue = await source.get(key);
-  if (isAsyncTree(sourceValue)) {
-    const targetValue = await target.get(key);
-    if (isAsyncTree(targetValue)) {
-      // Both source and target are async dictionaries; recurse.
-      await applyUpdates(sourceValue, targetValue);
-      return;
-    }
-  }
-
-  // Copy the value from the source to the target.
-  await target.set(key, sourceValue);
-}

package/test/operations/deepMap.test.js

@@ -1,29 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { DeepObjectTree, Tree } from "../../src/internal.js";
-import deepMap from "../../src/operations/deepMap.js";
-
-describe("deepMap", () => {
-  test("can map extensions deeply", async () => {
-    const treelike = new DeepObjectTree({
-      "file1.txt": "will be mapped",
-      file2: "won't be mapped",
-      "file3.foo": "won't be mapped",
-      more: {
-        "file4.txt": "will be mapped",
-        "file5.bar": "won't be mapped",
-      },
-    });
-    const fixture = await deepMap.call(null, treelike, {
-      deep: true,
-      extension: ".txt->.upper",
-      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
-    });
-    assert.deepEqual(await Tree.plain(fixture), {
-      "file1.upper": "WILL BE MAPPED",
-      more: {
-        "file4.upper": "WILL BE MAPPED",
-      },
-    });
-  });
-});

package/test/operations/defineds.test.js

@@ -1,25 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
-import defineds from "../../src/operations/defineds.js";
-
-describe("defineds", () => {
-  test("returns only defined values in a tree", async () => {
-    const obj = {
-      a: 1,
-      b: undefined,
-      c: null,
-      d: {
-        e: 2,
-        f: undefined,
-        g: {
-          h: 3,
-          i: undefined,
-        },
-      },
-    };
-    const result = await defineds(obj);
-    const plain = await Tree.plain(result);
-    assert.deepEqual(plain, { a: 1, d: { e: 2, g: { h: 3 } } });
-  });
-});

package/test/operations/setDeep.test.js

@@ -1,53 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
-import setDeep from "../../src/operations/setDeep.js";
-
-describe("tree/setDeep", () => {
-  test("can apply updates with a single argument to set", async () => {
-    const tree = new DeepObjectTree({
-      a: 1,
-      b: 2,
-      more: {
-        d: 3,
-      },
-    });
-
-    // Apply changes.
-    await setDeep.call(
-      null,
-      tree,
-      new DeepObjectTree({
-        a: 4, // Overwrite existing value
-        b: undefined, // Delete
-        c: 5, // Add
-        more: {
-          // Should leave existing `more` keys alone.
-          e: 6, // Add
-        },
-        // Add new subtree
-        extra: {
-          f: 7,
-        },
-      })
-    );
-
-    assert.deepEqual(await Tree.plain(tree), {
-      a: 4,
-      c: 5,
-      more: {
-        d: 3,
-        e: 6,
-      },
-      extra: {
-        f: 7,
-      },
-    });
-  });
-
-  test("can apply updates to an array", async () => {
-    const tree = new ObjectTree(["a", "b", "c"]);
-    await setDeep.call(null, tree, ["d", "e"]);
-    assert.deepEqual(await Tree.plain(tree), ["d", "e", "c"]);
-  });
-});