@weborigami/async-tree 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",

package/src/Tree.js

@@ -67,4 +67,5 @@ export { default as traverse } from "./operations/traverse.js";
 export { default as traverseOrThrow } from "./operations/traverseOrThrow.js";
 export { default as traversePath } from "./operations/traversePath.js";
 export { default as values } from "./operations/values.js";
+export { default as visit } from "./operations/visit.js";
 export { default as withKeys } from "./operations/withKeys.js";

package/src/drivers/ExplorableSiteMap.js

@@ -53,4 +53,6 @@ export default class ExplorableSiteMap extends SiteMap {
 
     return super.processResponse(response);
   }
+
+  trailingSlashKeys = true;
 }

package/src/operations/globKeys.js

@@ -24,9 +24,8 @@ export default async function globKeys(maplike) {
     },
 
     async *keys() {
-      for await (const key of source.keys()) {
-        yield key;
-      }
+      // Don't return globstar keys. When used, e.g., with a Tree.mask, we don't
+      // want the globstar keys to appear in the result.
     },
 
     trailingSlashKeys: /** @type {any} */ (source).trailingSlashKeys,

package/src/operations/map.js

@@ -167,9 +167,17 @@ function validateOptions(options) {
     valueFn = validateOption(options, "value");
 
     // Cast function options to functions
-    inverseKeyFn &&= toFunction(inverseKeyFn);
-    keyFn &&= toFunction(keyFn);
-    valueFn &&= toFunction(valueFn);
+    inverseKeyFn &&= castToFunction(inverseKeyFn, "inverseKey");
+    if (
+      typeof keyFn === "string" &&
+      (keyFn.includes("=>") || keyFn.includes("→"))
+    ) {
+      throw new TypeError(
+        `map: The key option appears to be an extension mapping. Did you mean to call Tree.mapExtension() ?`
+      );
+    }
+    keyFn &&= castToFunction(keyFn, "key");
+    valueFn &&= castToFunction(valueFn, "value");
   } else if (options === undefined) {
     /** @type {any} */
     const error = new TypeError(`map: The second parameter was undefined.`);
@@ -249,3 +257,13 @@ function validateOptions(options) {
     valueFn,
   };
 }
+
+function castToFunction(object, name) {
+  const fn = toFunction(object);
+  if (!fn) {
+    throw new TypeError(
+      `map: The ${name} option must be a function but couldn't be treated as one.`
+    );
+  }
+  return fn;
+}

package/src/operations/root.js

@@ -8,9 +8,9 @@ import getMapArgument from "../utilities/getMapArgument.js";
  *
  * @param {Maplike} maplike
  */
-export default function root(maplike) {
+export default async function root(maplike) {
   /** @type {any} */
-  let current = getMapArgument(maplike, "root");
+  let current = await getMapArgument(maplike, "root");
   while (current.parent || current[symbols.parent]) {
     current = current.parent || current[symbols.parent];
   }

package/src/operations/visit.js

@@ -0,0 +1,14 @@
+import getMapArgument from "../utilities/getMapArgument.js";
+import reduce from "./reduce.js";
+
+/**
+ * Visit every node in the tree and return `undefined`.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
+ *
+ * @param {Maplike} source
+ */
+export default async function visit(source) {
+  const tree = await getMapArgument(source, "visit", { deep: true });
+  return reduce(tree, () => undefined);
+}

package/test/operations/root.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import root from "../../src/operations/root.js";
+import traverse from "../../src/operations/traverse.js";
+
+describe("root", () => {
+  test("returns root of a tree", async () => {
+    const tree = new ObjectMap(
+      {
+        a: {
+          b: {
+            c: {},
+          },
+        },
+      },
+      { deep: true }
+    );
+    const c = await traverse(tree, "a", "b", "c");
+    const r = await root(c);
+    assert.strictEqual(r, tree);
+  });
+});

package/test/operations/visit.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import FunctionMap from "../../src/drivers/FunctionMap.js";
+import visit from "../../src/operations/visit.js";
+
+describe("visit", () => {
+  test("visits every node in the tree", async () => {
+    const values = [];
+    const map = new FunctionMap(
+      (key) => {
+        const value = `value for ${key}`;
+        values.push(value);
+        return value;
+      },
+      ["a", "b", "c"]
+    );
+    const result = await visit(map);
+    assert.strictEqual(result, undefined);
+    assert.deepStrictEqual(values, [
+      "value for a",
+      "value for b",
+      "value for c",
+    ]);
+  });
+});