@weborigami/async-tree 0.0.62 → 0.0.63

package/index.ts

@@ -29,7 +29,7 @@ export type ReduceFn = (values: any[], keys: any[]) => Promise<any>;
 
 export type StringLike = string | HasString;
 
-type NativeTreelike = 
+export type NativeTreelike = 
   any[] |
   AsyncTree |
   Function | 

package/package.json

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

package/src/ObjectTree.js

@@ -48,7 +48,7 @@ export default class ObjectTree {
   }
 
   async isKeyForSubtree(key) {
-    const value = this.object[key];
+    const value = await this.object[key];
     return Tree.isAsyncTree(value);
   }
 

package/src/Tree.d.ts

@@ -13,7 +13,8 @@ export function isKeyForSubtree(tree: AsyncTree, obj: any): Promise<boolean>;
 export function isTraversable(obj: any): boolean;
 export function isTreelike(obj: any): obj is Treelike;
 export function map(tree: Treelike, valueFn: ValueKeyFn): AsyncTree;
-export function mapReduce(tree: Treelike, mapFn: ValueKeyFn|null, reduceFn: ReduceFn): Promise<any>;
+export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
+export function paths(tree: Treelike, base: string): string[];
 export function plain(tree: Treelike): Promise<PlainObject>;
 export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;
 export function toFunction(tree: Treelike): Function;

package/src/Tree.js

@@ -134,6 +134,14 @@ export function from(object, options = {}) {
   } else if (object && typeof object === "object") {
     // An instance of some class.
     return new ObjectTree(object);
+  } else if (
+    typeof object === "string" ||
+    typeof object === "number" ||
+    typeof object === "boolean"
+  ) {
+    // A primitive value; box it into an object and construct a tree.
+    const boxed = utilities.box(object);
+    return new ObjectTree(boxed);
   }
 
   throw new TypeError("Couldn't convert argument to an async tree");
@@ -154,25 +162,23 @@ export async function has(tree, key) {
 /**
  * Return true if the indicated object is an async tree.
  *
- * @param {any} object
+ * @param {any} obj
  * @returns {obj is AsyncTree}
  */
-export function isAsyncTree(object) {
-  return (
-    object &&
-    typeof object.get === "function" &&
-    typeof object.keys === "function"
-  );
+export function isAsyncTree(obj) {
+  return obj && typeof obj.get === "function" && typeof obj.keys === "function";
 }
 
 /**
  * Return true if the indicated object is an async mutable tree.
  *
- * @param {any} object
+ * @param {any} obj
  * @returns {obj is AsyncMutableTree}
  */
-export function isAsyncMutableTree(object) {
-  return isAsyncTree(object) && typeof object.set === "function";
+export function isAsyncMutableTree(obj) {
+  return (
+    isAsyncTree(obj) && typeof (/** @type {any} */ (obj).set) === "function"
+  );
 }
 
 /**
@@ -219,16 +225,16 @@ export function isTraversable(object) {
  * Note: the `from()` method accepts any JavaScript object, but `isTreelike`
  * returns `false` for an object that isn't one of the above types.
  *
- * @param {any} object
+ * @param {any} obj
  * @returns {obj is Treelike}
  */
-export function isTreelike(object) {
+export function isTreelike(obj) {
   return (
-    isAsyncTree(object) ||
-    object instanceof Function ||
-    object instanceof Array ||
-    object instanceof Set ||
-    isPlainObject(object)
+    isAsyncTree(obj) ||
+    obj instanceof Function ||
+    obj instanceof Array ||
+    obj instanceof Set ||
+    isPlainObject(obj)
   );
 }
 
@@ -283,6 +289,27 @@ export async function mapReduce(treelike, valueFn, reduceFn) {
   return reduceFn(values, keys);
 }
 
+/**
+ * Returns slash-separated paths for all values in the tree.
+ *
+ * @param {Treelike} treelike
+ * @param {string} base
+ */
+export async function paths(treelike, base = "") {
+  const tree = from(treelike);
+  const result = [];
+  for (const key of await tree.keys()) {
+    const valuePath = base ? `${base}/${key}` : key;
+    const value = await tree.get(key);
+    if (await isAsyncTree(value)) {
+      const subPaths = await paths(value, valuePath);
+      result.push(...subPaths);
+    } else {
+      result.push(valuePath);
+    }
+  }
+  return result;
+}
 /**
  * Converts an asynchronous tree into a synchronous plain JavaScript object.
  *

package/src/operations/concat.js

@@ -7,7 +7,7 @@ import deepValuesIterator from "./deepValuesIterator.js";
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @this {AsyncTree|null}
- * @param {import("@weborigami/async-tree").Treelike} treelike
+ * @param {import("../../index.ts").Treelike} treelike
  */
 export default async function concatTreeValues(treelike) {
   const strings = [];

package/src/operations/scope.js

@@ -1,11 +1,11 @@
-import { Tree } from "@weborigami/async-tree";
+import { Tree } from "../internal.js";
 
 /**
  * A tree's "scope" is the collection of everything in that tree and all of its
  * ancestors.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("../../index.ts").Treelike} Treelike
  *
  * @param {Treelike} treelike
  * @returns {AsyncTree & {trees: AsyncTree[]}}

package/src/transforms/sortFn.js

@@ -50,16 +50,14 @@ export default function sortFn(options) {
         const defaultCompare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
         const originalCompare = compare ?? defaultCompare;
         // Sort by the sort key.
-        const sortedTuples = tuples.toSorted((a, b) =>
-          originalCompare(a.sort, b.sort)
-        );
+        tuples.sort((a, b) => originalCompare(a.sort, b.sort));
         // Map back to the original keys.
-        const sorted = sortedTuples.map((pair) => pair.key);
+        const sorted = tuples.map((pair) => pair.key);
         return sorted;
       } else {
         // Use original keys as sort keys.
         // If compare is undefined, this uses default sort order.
-        return keys.toSorted(compare);
+        return keys.slice().sort(compare);
       }
     };
     return transformed;

package/src/utilities.d.ts

@@ -5,10 +5,10 @@ export function box(value: any): any;
 export function castArrayLike(object: any): any;
 export function getRealmObjectPrototype(object: any): any;
 export const hiddenFileNames: string[];
-export function isPacked(object: any): object is Packed;
-export function isPlainObject(object: any): object is PlainObject;
-export function isUnpackable(object): object is { unpack: () => any };
-export function isStringLike(object: any): object is StringLike;
+export function isPacked(obj: any): obj is Packed;
+export function isPlainObject(obj: any): obj is PlainObject;
+export function isStringLike(obj: any): obj is StringLike;
+export function isUnpackable(obj): obj is { unpack: () => any };
 export function keysFromPath(path: string): string[];
 export const naturalOrder: (a: string, b: string) => number;
 export function pipeline(start: any, ...functions: Function[]): Promise<any>;

package/src/utilities.js

@@ -73,16 +73,16 @@ export const hiddenFileNames = [".DS_Store"];
  * Return true if the object is in a packed form (or can be readily packed into
  * a form) that can be given to fs.writeFile or response.write().
  *
- * @param {any} object
- * @returns {object is import("../index.ts").Packed}
+ * @param {any} obj
+ * @returns {obj is import("../index.ts").Packed}
  */
-export function isPacked(object) {
+export function isPacked(obj) {
   return (
-    typeof object === "string" ||
-    object instanceof ArrayBuffer ||
-    object instanceof ReadableStream ||
-    object instanceof String ||
-    object instanceof TypedArray
+    typeof obj === "string" ||
+    obj instanceof ArrayBuffer ||
+    obj instanceof ReadableStream ||
+    obj instanceof String ||
+    obj instanceof TypedArray
   );
 }
 
@@ -93,23 +93,23 @@ export function isPacked(object) {
  * This function also considers object-like things with no prototype (like a
  * `Module`) as plain objects.
  *
- * @param {any} object
- * @returns {object is import("../index.ts").PlainObject}
+ * @param {any} obj
+ * @returns {obj is import("../index.ts").PlainObject}
  */
-export function isPlainObject(object) {
+export function isPlainObject(obj) {
   // From https://stackoverflow.com/q/51722354/76472
-  if (typeof object !== "object" || object === null) {
+  if (typeof obj !== "object" || obj === null) {
     return false;
   }
 
   // We treat object-like things with no prototype (like a Module) as plain
   // objects.
-  if (Object.getPrototypeOf(object) === null) {
+  if (Object.getPrototypeOf(obj) === null) {
     return true;
   }
 
   // Do we inherit directly from Object in this realm?
-  return Object.getPrototypeOf(object) === getRealmObjectPrototype(object);
+  return Object.getPrototypeOf(obj) === getRealmObjectPrototype(obj);
 }
 
 /**
@@ -130,15 +130,15 @@ export function isPrimitive(value) {
  * Return true if the object is a string or object with a non-trival `toString`
  * method.
  *
- * @param {any} object
+ * @param {any} obj
  * @returns {obj is import("../index.ts").StringLike}
  */
-export function isStringLike(object) {
-  if (typeof object === "string") {
+export function isStringLike(obj) {
+  if (typeof obj === "string") {
     return true;
-  } else if (object?.toString === undefined) {
+  } else if (obj?.toString === undefined) {
     return false;
-  } else if (object.toString === getRealmObjectPrototype(object)?.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.
@@ -148,10 +148,9 @@ export function isStringLike(object) {
   }
 }
 
-export function isUnpackable(object) {
+export function isUnpackable(obj) {
   return (
-    isPacked(object) &&
-    typeof (/** @type {any} */ (object).unpack) === "function"
+    isPacked(obj) && typeof (/** @type {any} */ (obj).unpack) === "function"
   );
 }
 

package/test/Tree.test.js

@@ -118,6 +118,13 @@ describe("Tree", () => {
     });
   });
 
+  test("from() autoboxes primitive values", async () => {
+    const tree = Tree.from("Hello, world.");
+    const slice = await tree.get("slice");
+    const result = await slice(0, 5);
+    assert.equal(result, "Hello");
+  });
+
   test("has returns true if the key exists", async () => {
     const fixture = createFixture();
     assert.equal(await Tree.has(fixture, "Alice.md"), true);
@@ -208,6 +215,18 @@ describe("Tree", () => {
     assert.deepEqual(reduced, "1234");
   });
 
+  test("paths returns an array of paths to the values in the tree", async () => {
+    const tree = new DeepObjectTree({
+      a: 1,
+      b: 2,
+      c: {
+        d: 3,
+        e: 4,
+      },
+    });
+    assert.deepEqual(await Tree.paths(tree), ["a", "b", "c/d", "c/e"]);
+  });
+
   test("plain() produces a plain object version of a tree", async () => {
     const original = {
       a: 1,

package/test/utilities.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { symbols } from "../main.js";
 import { ObjectTree } from "../src/internal.js";
+import * as symbols from "../src/symbols.js";
 import * as utilities from "../src/utilities.js";
 
 describe("utilities", () => {