@weborigami/async-tree 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.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/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);
+  });
+});