@weborigami/async-tree 0.2.12 → 0.3.0

package/package.json

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

package/shared.js

@@ -26,6 +26,7 @@ export { default as filter } from "./src/operations/filter.js";
 export { default as group } from "./src/operations/group.js";
 export { default as invokeFunctions } from "./src/operations/invokeFunctions.js";
 export { default as map } from "./src/operations/map.js";
+export { default as mask } from "./src/operations/mask.js";
 export { default as merge } from "./src/operations/merge.js";
 export { default as paginate } from "./src/operations/paginate.js";
 export { default as reverse } from "./src/operations/reverse.js";

package/src/operations/addNextPrevious.js

@@ -1,11 +1,11 @@
-import { Tree } from "@weborigami/async-tree";
+import { Tree } from "../internal.js";
 import { assertIsTreelike } from "../utilities.js";
 
 /**
  * Add nextKey/previousKey properties to values.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
+ * @typedef {import("../../index.ts").PlainObject} PlainObject
  *
  * @param {import("../../index.ts").Treelike} treelike
  * @returns {Promise<PlainObject|Array>}

package/src/operations/filter.js

@@ -1,53 +1,39 @@
-import { assertIsTreelike, trailingSlash, Tree } from "@weborigami/async-tree";
+import { assertIsTreelike } from "../utilities.js";
+import map from "./map.js";
 
 /**
- * Given trees `a` and `b`, return a filtered version of `a` where only the keys
- * that exist in `b` and have truthy values are kept. The filter operation is
- * deep: if a value from `a` is a subtree, it will be filtered recursively.
+ * Given a tree an a test function, return a new tree whose keys correspond to
+ * the values that pass the test function.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("../../index.ts").Treelike} Treelike
  *
- * @param {Treelike} a
- * @param {Treelike} b
+ * @param {Treelike} treelike
+ * @param {function|any} options
  * @returns {AsyncTree}
  */
-export default function filter(a, b) {
-  assertIsTreelike(a, "filter", 0);
-  assertIsTreelike(b, "filter", 1);
-  a = Tree.from(a);
-  b = Tree.from(b, { deep: true });
+export default function filter(treelike, options) {
+  assertIsTreelike(treelike, "map");
+  let testFn;
+  let deep;
+  if (typeof options === "function") {
+    testFn = options;
+    deep = false;
+  } else {
+    testFn = options.test;
+    deep = options.deep ?? false;
+  }
 
-  return {
-    async get(key) {
-      // The key must exist in b and return a truthy value
-      const bValue = await b.get(key);
-      if (!bValue) {
-        return undefined;
-      }
-      let aValue = await a.get(key);
-      if (Tree.isTreelike(aValue)) {
-        // Filter the subtree
-        return filter(aValue, bValue);
-      } else {
-        return aValue;
-      }
-    },
+  return map(treelike, {
+    deep,
+
+    // Assume source key is the same as result key
+    inverseKey: async (resultKey) => resultKey,
 
-    async keys() {
-      // Use a's keys as the basis
-      const aKeys = [...(await a.keys())];
-      const bValues = await Promise.all(aKeys.map((key) => b.get(key)));
-      // An async tree value in b implies that the a key should have a slash
-      const aKeySlashes = aKeys.map((key, index) =>
-        trailingSlash.toggle(
-          key,
-          trailingSlash.has(key) || Tree.isAsyncTree(bValues[index])
-        )
-      );
-      // Remove keys that don't have values in b
-      const keys = aKeySlashes.filter((key, index) => bValues[index] ?? false);
-      return keys;
+    key: async (sourceKey, tree) => {
+      const value = await tree.get(sourceKey);
+      const passes = await testFn(value, sourceKey, tree);
+      return passes ? sourceKey : undefined;
     },
-  };
+  });
 }

package/src/operations/globKeys.js

@@ -1,9 +1,13 @@
-import { ObjectTree, Tree, merge, trailingSlash } from "@weborigami/async-tree";
+import { ObjectTree, Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
+import { assertIsTreelike } from "../utilities.js";
+import merge from "./merge.js";
 
 const globstar = "**";
 const globstarSlash = `${globstar}/`;
 
 export default function globKeys(treelike) {
+  assertIsTreelike(treelike, "globKeys");
   const globs = Tree.from(treelike, { deep: true });
   return {
     async get(key) {

package/src/operations/mask.js

@@ -0,0 +1,55 @@
+import { Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
+import { assertIsTreelike } from "../utilities.js";
+
+/**
+ * Given trees `a` and `b`, return a masked version of `a` where only the keys
+ * that exist in `b` and have truthy values are kept. The filter operation is
+ * deep: if a value from `a` is a subtree, it will be filtered recursively.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").Treelike} Treelike
+ *
+ * @param {Treelike} a
+ * @param {Treelike} b
+ * @returns {AsyncTree}
+ */
+export default function mask(a, b) {
+  assertIsTreelike(a, "filter", 0);
+  assertIsTreelike(b, "filter", 1);
+  a = Tree.from(a);
+  b = Tree.from(b, { deep: true });
+
+  return {
+    async get(key) {
+      // The key must exist in b and return a truthy value
+      const bValue = await b.get(key);
+      if (!bValue) {
+        return undefined;
+      }
+      let aValue = await a.get(key);
+      if (Tree.isTreelike(aValue)) {
+        // Filter the subtree
+        return mask(aValue, bValue);
+      } else {
+        return aValue;
+      }
+    },
+
+    async keys() {
+      // Use a's keys as the basis
+      const aKeys = [...(await a.keys())];
+      const bValues = await Promise.all(aKeys.map((key) => b.get(key)));
+      // An async tree value in b implies that the a key should have a slash
+      const aKeySlashes = aKeys.map((key, index) =>
+        trailingSlash.toggle(
+          key,
+          trailingSlash.has(key) || Tree.isAsyncTree(bValues[index])
+        )
+      );
+      // Remove keys that don't have values in b
+      const keys = aKeySlashes.filter((key, index) => bValues[index] ?? false);
+      return keys;
+    },
+  };
+}

package/test/drivers/constantTree.test.js

@@ -1,7 +1,7 @@
-import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import constantTree from "../../src/drivers/constantTree.js";
+import { Tree } from "../../src/internal.js";
 
 describe("constantTree", () => {
   test("returns a deep tree that returns constant for all keys", async () => {

package/test/jsonKeys.test.js

@@ -1,6 +1,6 @@
-import { DeepObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { DeepObjectTree } from "../src/internal.js";
 import * as jsonKeys from "../src/jsonKeys.js";
 
 describe("jsonKeys", () => {

package/test/operations/filter.test.js

@@ -4,8 +4,24 @@ import { Tree } from "../../src/internal.js";
 import filter from "../../src/operations/filter.js";
 
 describe("filter", () => {
-  test("removes keys and values whose filter values are falsy", async () => {
-    const result = filter(
+  test("returns values that pass a filter function", async () => {
+    const result = await filter(
+      {
+        a: 1,
+        b: 2,
+        c: 3,
+        d: 4,
+      },
+      (value) => value % 2 === 1 // odd
+    );
+    assert.deepEqual(await Tree.plain(result), {
+      a: 1,
+      c: 3,
+    });
+  });
+
+  test("returns deep values that pass a filter function", async () => {
+    const result = await filter(
       {
         a: 1,
         b: 2,
@@ -15,13 +31,10 @@ describe("filter", () => {
         },
       },
       {
-        a: true,
-        c: {
-          d: true,
-        },
+        deep: true,
+        test: (value) => value % 2 === 1, // odd
       }
     );
-    assert.deepEqual(await result.keys(), ["a", "c/"]);
     assert.deepEqual(await Tree.plain(result), {
       a: 1,
       c: {

package/test/operations/globKeys.test.js

@@ -1,6 +1,6 @@
-import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
 import globKeys from "../../src/operations/globKeys.js";
 
 describe("globKeys", () => {

package/test/operations/mask.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import mask from "../../src/operations/mask.js";
+
+describe("mask", () => {
+  test("removes keys and values whose mask values are falsy", async () => {
+    const result = mask(
+      {
+        a: 1,
+        b: 2,
+        c: {
+          d: 3,
+          e: 4,
+        },
+      },
+      {
+        a: true,
+        c: {
+          d: true,
+        },
+      }
+    );
+    assert.deepEqual(await result.keys(), ["a", "c/"]);
+    assert.deepEqual(await Tree.plain(result), {
+      a: 1,
+      c: {
+        d: 3,
+      },
+    });
+  });
+});