@weborigami/async-tree 0.7.0-beta.1 → 0.7.0-beta.2

package/package.json

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

package/src/Tree.js

@@ -25,6 +25,8 @@ export { default as deflatePaths } from "./operations/deflatePaths.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 find } from "./operations/find.js";
+export { default as findKey } from "./operations/findKey.js";
 export { default as first } from "./operations/first.js";
 export { default as flat } from "./operations/flat.js";
 export { default as forEach } from "./operations/forEach.js";

package/src/drivers/AsyncMap.js

@@ -28,6 +28,7 @@ export default class AsyncMap {
     if (!isMap(result)) {
       // Create new child node using no-arg constructor
       result = new /** @type {any} */ (this.constructor)();
+      result.trailingSlashKeys = this.trailingSlashKeys;
       await this.set(key, result);
     }
 

package/src/drivers/SyncMap.js

@@ -49,6 +49,7 @@ export default class SyncMap extends Map {
     if (!(result instanceof Map)) {
       // Create new child node using no-arg constructor
       result = new /** @type {any} */ (this.constructor)();
+      result.trailingSlashKeys = this.trailingSlashKeys;
       this.set(key, result);
     }
 

package/src/operations/find.js

@@ -0,0 +1,21 @@
+import * as args from "../utilities/args.js";
+
+/**
+ * Return the first value in the map that satisfies the given predicate
+ * function.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
+ *
+ * @param {Maplike} maplike
+ * @param {Function} predicate
+ */
+export default async function find(maplike, predicate) {
+  const map = await args.map(maplike, "Tree.find");
+  for await (const key of map.keys()) {
+    const value = await map.get(key);
+    if (await predicate(value, key, map)) {
+      return value;
+    }
+  }
+  return undefined;
+}

package/src/operations/findKey.js

@@ -0,0 +1,21 @@
+import * as args from "../utilities/args.js";
+
+/**
+ * Return the first key in the map that satisfies the given predicate
+ * function.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
+ *
+ * @param {Maplike} maplike
+ * @param {Function} predicate
+ */
+export default async function findKey(maplike, predicate) {
+  const map = await args.map(maplike, "Tree.findKey");
+  for await (const key of map.keys()) {
+    const value = await map.get(key);
+    if (await predicate(value, key, map)) {
+      return key;
+    }
+  }
+  return undefined;
+}

package/src/operations/from.js

@@ -2,13 +2,16 @@ import AsyncMap from "../drivers/AsyncMap.js";
 import FunctionMap from "../drivers/FunctionMap.js";
 import ObjectMap from "../drivers/ObjectMap.js";
 import SetMap from "../drivers/SetMap.js";
+import SyncMap from "../drivers/SyncMap.js";
 import * as symbols from "../symbols.js";
 import box from "../utilities/box.js";
-import isPlainObject from "../utilities/isPlainObject.js";
 import setParent from "../utilities/setParent.js";
 import TypedArray from "../utilities/TypedArray.js";
 import isMap from "./isMap.js";
 
+// Base class for async functions
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
 /**
  * Attempts to cast the indicated object to a map.
  *
@@ -42,15 +45,17 @@ export default function from(object, options = {}) {
     map = new SetMap(object);
   } else if (object instanceof ArrayBuffer || object instanceof TypedArray) {
     throw new TypeError("Can't treat binary file data as a map.");
-  } else if (isPlainObject(object) || object instanceof Array) {
-    map = new ObjectMap(object, { deep });
     // @ts-ignore
   } else if (globalThis.Iterator && object instanceof Iterator) {
     const array = Array.from(object);
     map = new ObjectMap(array, { deep });
-  } else if (object && typeof object === "object") {
-    // An instance of some class.
-    map = new ObjectMap(object, { deep });
+  } else if (typeof object === "object") {
+    if (typeof object.get === "function" && typeof object.keys === "function") {
+      map = upgradeToMap(object);
+    } else {
+      // A plain object, array, or instance of some class
+      map = new ObjectMap(object, { deep });
+    }
   } else if (
     typeof object === "string" ||
     typeof object === "number" ||
@@ -69,3 +74,10 @@ export default function from(object, options = {}) {
 
   return map;
 }
+
+function upgradeToMap(object) {
+  const isAsync =
+    object.get instanceof AsyncFunction || object.keys instanceof AsyncFunction;
+  const baseClass = isAsync ? AsyncMap : SyncMap;
+  return Object.assign(new baseClass(), object);
+}

package/src/operations/inflatePaths.js

@@ -5,23 +5,24 @@ import keysFromPath from "../utilities/keysFromPath.js";
 /**
  * Given a mapping of string paths to values, return the described tree.
  */
-export default async function inflatePaths(maplike) {
-  const map = await args.map(maplike, "Tree.inflatePaths", { deep: true });
+export default async function inflatePaths(maplike, options = {}) {
+  const map = await args.map(maplike, "Tree.inflatePaths");
 
-  const result = new SyncMap();
+  const classFn = options.classFn ?? SyncMap;
+  const result = new classFn();
   for await (const [path, value] of map) {
     const keys = keysFromPath(path);
-    setValue(result, keys, value);
+    setValue(result, keys, value, classFn);
   }
   return result;
 }
 
 // Add the value to the tree at the given path of keys
-function setValue(map, keys, value) {
+function setValue(map, keys, value, classFn) {
   let node = map;
   for (const key of keys.slice(0, -1)) {
     // Create a new node if one doesn't exist yet
-    node = node.getOrInsertComputed(key, () => new SyncMap());
+    node = node.getOrInsertComputed(key, () => new classFn());
   }
   node.set(keys[keys.length - 1], value);
 }

package/test/operations/find.test.js

@@ -0,0 +1,10 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import find from "../../src/operations/find.js";
+
+describe("find", () => {
+  test("returns the first value that satisfies the predicate", async () => {
+    const result = await find([5, 12, 8], (e) => e > 10);
+    assert.strictEqual(result, 12);
+  });
+});

package/test/operations/findKey.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import findKey from "../../src/operations/findKey.js";
+
+describe("findKey", () => {
+  test("returns the first key that satisfies the predicate", async () => {
+    const object = {
+      a: 5,
+      b: 12,
+      c: 8,
+    };
+    const result = await findKey(object, (e) => e > 10);
+    assert.strictEqual(result, "b");
+  });
+});

package/test/operations/from.test.js

@@ -58,4 +58,22 @@ describe("from", () => {
     const result = await slice(0, 5);
     assert.equal(result, "Hello");
   });
+
+  test("upgrades object with get/keys to a Map", () => {
+    const object = {
+      get(key) {
+        return key.toUpperCase();
+      },
+
+      *keys() {
+        yield "a";
+        yield "b";
+      },
+    };
+    const tree = from(object);
+    // @ts-ignore
+    assert.deepEqual([...tree.keys()], ["a", "b"]);
+    assert.equal(tree.get("a"), "A");
+    assert.equal(tree.get("b"), "B");
+  });
 });