@weborigami/async-tree 0.0.47 → 0.0.49

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.11.27",
-    "typescript": "5.4.2"
+    "@types/node": "20.12.8",
+    "typescript": "5.4.5"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.47"
+    "@weborigami/types": "0.0.49"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/FileTree.js

@@ -189,7 +189,7 @@ function isStringLike(obj) {
     return true;
   } else if (obj?.toString === undefined) {
     return false;
-  } else if (obj.toString === getRealmObjectPrototype(obj).toString) {
+  } else if (obj.toString === getRealmObjectPrototype(obj)?.toString) {
     // The stupid Object.prototype.toString implementation always returns
     // "[object Object]", so if that's the only toString method the object has,
     // we return false.

package/src/Tree.js

@@ -388,11 +388,16 @@ export async function traverseOrThrow(treelike, ...keys) {
       value = await value.unpack();
     }
 
-    // Peek ahead: if there's only one key left and it's an empty string, return
-    // the value itself.
-    if (remainingKeys.length === 1 && remainingKeys[0] === "") {
-      return value;
-    } else if (value instanceof Function) {
+    if (!isTreelike(value)) {
+      // Value isn't treelike, so can't be traversed except for a special case:
+      // if there's only one key left and it's an empty string, return the
+      // non-treelike value.
+      if (remainingKeys.length === 1 && remainingKeys[0] === "") {
+        return value;
+      }
+    }
+
+    if (value instanceof Function) {
       // Value is a function: call it with the remaining keys.
       const fn = value;
       // We'll take as many keys as the function's length, but at least one.
@@ -401,12 +406,20 @@ export async function traverseOrThrow(treelike, ...keys) {
       key = null;
       value = await fn.call(target, ...args);
     } else {
+      const originalValue = value;
+
       // Value is some other treelike object: cast it to a tree.
       const tree = from(value);
       // Get the next key.
       key = remainingKeys.shift();
       // Get the value for the key.
       value = await tree.get(key);
+
+      // The empty key as the final key is a special case: if the tree doesn't
+      // have a value for the empty key, use the original value.
+      if (value === undefined && remainingKeys.length === 0 && key === "") {
+        value = originalValue;
+      }
     }
   }
 

package/src/operations/merge.js

@@ -1,3 +1,5 @@
+import { Tree } from "../internal.js";
+
 /**
  * Return a tree that performs a shallow merge of the given trees.
  *
@@ -8,10 +10,11 @@
  * return a defined value, the `get` method returns undefined.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @param {import("../../index.ts").Treelike[]} sources
  * @returns {AsyncTree & { description: string }}
  */
 export default function merge(...sources) {
-  let trees = sources;
+  let trees = sources.map((treelike) => Tree.from(treelike));
   let mergeParent;
   return {
     description: "merge",
@@ -28,7 +31,7 @@ export default function merge(...sources) {
 
     async isKeyForSubtree(key) {
       for (const tree of trees) {
-        if (await tree.isKeyForSubtree(key)) {
+        if (await Tree.isKeyForSubtree(tree, key)) {
           return true;
         }
       }
@@ -50,8 +53,10 @@ export default function merge(...sources) {
     },
     set parent(parent) {
       mergeParent = parent;
-      trees = sources.map((source) => {
-        const tree = Object.create(source);
+      trees = sources.map((treelike) => {
+        const tree = Tree.isAsyncTree(treelike)
+          ? Object.create(treelike)
+          : Tree.from(treelike);
         tree.parent = parent;
         return tree;
       });

package/src/operations/mergeDeep.js

@@ -4,9 +4,12 @@ import { Tree } from "../internal.js";
  * Return a tree that performs a deep merge of the given trees.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @param {import("../../index.ts").Treelike[]} sources
  * @returns {AsyncTree & { description: string }}
  */
-export default function mergeDeep(...trees) {
+export default function mergeDeep(...sources) {
+  let trees = sources.map((treelike) => Tree.from(treelike));
+  let mergeParent;
   return {
     description: "mergeDeep",
 
@@ -27,7 +30,7 @@ export default function mergeDeep(...trees) {
 
     async isKeyForSubtree(key) {
       for (const tree of trees) {
-        if (await tree.isKeyForSubtree(key)) {
+        if (await Tree.isKeyForSubtree(tree, key)) {
           return true;
         }
       }
@@ -43,5 +46,19 @@ export default function mergeDeep(...trees) {
       }
       return keys;
     },
+
+    get parent() {
+      return mergeParent;
+    },
+    set parent(parent) {
+      mergeParent = parent;
+      trees = sources.map((treelike) => {
+        const tree = Tree.isAsyncTree(treelike)
+          ? Object.create(treelike)
+          : Tree.from(treelike);
+        tree.parent = parent;
+        return tree;
+      });
+    },
   };
 }

package/src/transforms/groupBy.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, Tree } from "../internal.js";
+import { ObjectTree, Tree } from "../internal.js";
 
 /**
  * Given a function that returns a grouping key for a value, returns a transform
@@ -36,6 +36,6 @@ export default function createGroupByTransform(groupKeyFn) {
       }
     }
 
-    return new DeepObjectTree(result);
+    return new ObjectTree(result);
   };
 }

package/src/transforms/map.js

@@ -1,4 +1,5 @@
-import { Tree } from "../internal.js";
+import { ObjectTree, Tree } from "../internal.js";
+import { isPlainObject } from "../utilities.js";
 
 /**
  * Return a transform function that maps the keys and/or values of a tree.
@@ -45,7 +46,11 @@ export default function createMapTransform(options = {}) {
    * @type {import("../../index.ts").TreeTransform}
    */
   return function map(treelike) {
-    const tree = Tree.from(treelike);
+    const tree =
+      !deep && isPlainObject(treelike) && !Tree.isAsyncTree(treelike)
+        ? new ObjectTree(treelike)
+        : Tree.from(treelike);
+
     // The transformed tree is actually an extension of the original tree's
     // prototype chain. This allows the transformed tree to inherit any
     // properties/methods. For example, the `parent` of the transformed tree is

package/src/utilities.js

@@ -30,6 +30,10 @@ export function castArrayLike(object) {
  * @param {any} object
  */
 export function getRealmObjectPrototype(object) {
+  if (Object.getPrototypeOf(object) === null) {
+    // The object has no prototype.
+    return null;
+  }
   let proto = object;
   while (Object.getPrototypeOf(proto) !== null) {
     proto = Object.getPrototypeOf(proto);
@@ -96,7 +100,7 @@ export function isStringLike(object) {
     return true;
   } else if (object?.toString === undefined) {
     return false;
-  } else if (object.toString === getRealmObjectPrototype(object).toString) {
+  } else if (object.toString === getRealmObjectPrototype(object)?.toString) {
     // The stupid Object.prototype.toString implementation always returns
     // "[object Object]", so if that's the only toString method the object has,
     // we return false.