@weborigami/async-tree 0.3.3 → 0.3.4-jse.5

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.3.3",
+  "version": "0.3.4-jse.5",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "dependencies": {
-    "@weborigami/types": "0.3.3"
+    "@weborigami/types": "0.3.4-jse.5"
   },
   "devDependencies": {
     "@types/node": "22.13.13",

package/shared.js

@@ -14,7 +14,6 @@ export * as jsonKeys from "./src/jsonKeys.js";
 export { default as addNextPrevious } from "./src/operations/addNextPrevious.js";
 export { default as cache } from "./src/operations/cache.js";
 export { default as cachedKeyFunctions } from "./src/operations/cachedKeyFunctions.js";
-export { default as concat } from "./src/operations/concat.js";
 export { default as deepMerge } from "./src/operations/deepMerge.js";
 export { default as deepReverse } from "./src/operations/deepReverse.js";
 export { default as deepTake } from "./src/operations/deepTake.js";
@@ -34,6 +33,7 @@ export { default as reverse } from "./src/operations/reverse.js";
 export { default as scope } from "./src/operations/scope.js";
 export { default as sort } from "./src/operations/sort.js";
 export { default as take } from "./src/operations/take.js";
+export { default as text } from "./src/operations/text.js";
 export * as symbols from "./src/symbols.js";
 export * as trailingSlash from "./src/trailingSlash.js";
 export { default as TraverseError } from "./src/TraverseError.js";

package/src/Tree.d.ts

@@ -21,4 +21,4 @@ export function toFunction(tree: Treelike): Function;
 export function traverse(tree: Treelike, ...keys: any[]): Promise<any>;
 export function traverseOrThrow(tree: Treelike, ...keys: any[]): Promise<any>;
 export function traversePath(tree: Treelike, path: string): Promise<any>;
-export function values(AsyncTree: AsyncTree): Promise<IterableIterator<any>>;
+export function values(tree: Treelike): Promise<IterableIterator<any>>;

package/src/Tree.js

@@ -26,8 +26,6 @@ import {
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
-const treeModule = this;
-
 /**
  * Apply the key/values pairs from the source tree to the target tree.
  *
@@ -362,8 +360,8 @@ export async function remove(tree, key) {
  */
 export function root(tree) {
   let current = from(tree);
-  while (current.parent) {
-    current = current.parent;
+  while (current.parent || current[symbols.parent]) {
+    current = current.parent || current[symbols.parent];
   }
   return current;
 }
@@ -416,7 +414,7 @@ export async function traverseOrThrow(treelike, ...keys) {
 
   // If traversal operation was called with a `this` context, use that as the
   // target for function calls.
-  const target = this === treeModule ? undefined : this;
+  const target = this;
 
   // Process all the keys.
   const remainingKeys = keys.slice();
@@ -473,9 +471,10 @@ export async function traversePath(tree, path) {
 /**
  * Return the values in the specific node of the tree.
  *
- * @param {AsyncTree} tree
+ * @param {Treelike} treelike
  */
-export async function values(tree) {
+export async function values(treelike) {
+  const tree = from(treelike);
   const keys = Array.from(await tree.keys());
   const promises = keys.map(async (key) => tree.get(key));
   return Promise.all(promises);

package/src/drivers/FileTree.js

@@ -92,7 +92,12 @@ export default class FileTree {
       value = Uint8Array.from(buffer);
     }
 
-    setParent(value, this);
+    const parent =
+      key === ".."
+        ? // Special case: ".." parent is the grandparent (if it exists)
+          this.parent?.parent
+        : this;
+    setParent(value, parent);
     return value;
   }
 

package/src/drivers/limitConcurrency.js

@@ -25,7 +25,7 @@ export default function limitConcurrency(fn, maxConcurrency) {
     // Join the queue
     queue.push({
       promise: resultPromise,
-      resolve: turnWithResolvers.resolve,
+      unblock: turnWithResolvers.resolve,
     });
 
     if (activeCallPool.size >= maxConcurrency) {
@@ -39,13 +39,14 @@ export default function limitConcurrency(fn, maxConcurrency) {
     return resultPromise;
   };
 
-  // If there are calls in the queue and the active pool is not full, resolve
-  // the next call in the queue and add it to the active pool.
+  // If there are calls in the queue and the active pool is not full, start
+  // the next call in the queue.
   function next() {
     if (queue.length > 0 && activeCallPool.size < maxConcurrency) {
-      const { promise, resolve } = queue.shift();
+      const { promise, unblock } = queue.shift();
       activeCallPool.add(promise);
-      resolve();
+      // Resolve the turn promise to allow the call to proceed
+      unblock();
     }
   }
 }

package/src/operations/deepText.js

@@ -1,25 +1,29 @@
-import { Tree } from "../internal.js";
-import { toString } from "../utilities.js";
-import concat from "./concat.js";
+import { assertIsTreelike, toString } from "../utilities.js";
+import deepValuesIterator from "./deepValuesIterator.js";
 
 /**
- * A tagged template literal function that concatenate the deep text values in a
- * tree. Any treelike values will be concatenated using `concat`.
+ * Concatenate the deep text values in a tree.
  *
- * @param {TemplateStringsArray} strings
- * @param  {...any} values
+ * @param {import("../../index.ts").Treelike} treelike
  */
-export default async function deepText(strings, ...values) {
-  // Convert all the values to strings
-  const valueTexts = await Promise.all(
-    values.map((value) =>
-      Tree.isTreelike(value) ? concat(value) : toString(value)
-    )
-  );
-  // Splice all the strings together
-  let result = strings[0];
-  for (let i = 0; i < valueTexts.length; i++) {
-    result += valueTexts[i] + strings[i + 1];
+export default async function deepText(treelike) {
+  assertIsTreelike(treelike, "text");
+
+  const strings = [];
+  for await (const value of deepValuesIterator(treelike, { expand: true })) {
+    let string;
+    if (value === null) {
+      string = "null";
+    } else if (value === undefined) {
+      string = "undefined";
+    } else {
+      string = toString(value);
+    }
+    if (value === null || value === undefined) {
+      const message = `Warning: a template encountered a ${string} value. To locate where this happened, build your project and search your build output for the text "${string}".`;
+      console.warn(message);
+    }
+    strings.push(string);
   }
-  return result;
+  return strings.join("");
 }

package/src/operations/merge.js

@@ -16,7 +16,17 @@ import * as trailingSlash from "../trailingSlash.js";
  * @returns {AsyncTree & { description: string, trees: AsyncTree[]}}
  */
 export default function merge(...sources) {
-  const trees = sources.map((treelike) => Tree.from(treelike));
+  const trees = sources
+    .filter((source) => source)
+    .map((treelike) => Tree.from(treelike));
+
+  if (trees.length === 0) {
+    throw new TypeError("merge: all trees are null or undefined");
+  } else if (trees.length === 1) {
+    // Only one tree, no need to merge
+    return trees[0];
+  }
+
   return {
     description: "merge",
 

package/src/operations/text.js

@@ -0,0 +1,25 @@
+import { Tree } from "../internal.js";
+import { toString } from "../utilities.js";
+import deepText from "./deepText.js";
+
+/**
+ * A tagged template literal function that concatenate the deep text values in a
+ * tree. Any treelike values will be concatenated using `deepText`.
+ *
+ * @param {TemplateStringsArray} strings
+ * @param  {...any} values
+ */
+export default async function text(strings, ...values) {
+  // Convert all the values to strings
+  const valueTexts = await Promise.all(
+    values.map((value) =>
+      Tree.isTreelike(value) ? deepText(value) : toString(value)
+    )
+  );
+  // Splice all the strings together
+  let result = strings[0];
+  for (let i = 0; i < valueTexts.length; i++) {
+    result += valueTexts[i] + strings[i + 1];
+  }
+  return result;
+}

package/src/utilities.js

@@ -279,17 +279,22 @@ export function setParent(child, parent) {
       child.parent = parent;
     }
   } else if (Object.isExtensible(child) && !child[symbols.parent]) {
-    // Add parent reference as a symbol to avoid polluting the object. This
-    // reference will be used if the object is later used as a tree. We set
-    // `enumerable` to false even thought this makes no practical difference
-    // (symbols are never enumerated) because it can provide a hint in the
-    // debugger that the property is for internal use.
-    Object.defineProperty(child, symbols.parent, {
-      configurable: true,
-      enumerable: false,
-      value: parent,
-      writable: true,
-    });
+    try {
+      // Add parent reference as a symbol to avoid polluting the object. This
+      // reference will be used if the object is later used as a tree. We set
+      // `enumerable` to false even thought this makes no practical difference
+      // (symbols are never enumerated) because it can provide a hint in the
+      // debugger that the property is for internal use.
+      Object.defineProperty(child, symbols.parent, {
+        configurable: true,
+        enumerable: false,
+        value: parent,
+        writable: true,
+      });
+    } catch (error) {
+      // Ignore exceptions. Some esoteric objects don't allow adding properties.
+      // We can still treat them as trees, but they won't have a parent.
+    }
   }
 }
 

package/test/operations/deepText.test.js

@@ -1,12 +1,34 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import FunctionTree from "../../src/drivers/FunctionTree.js";
+import { Tree } from "../../src/internal.js";
 import deepText from "../../src/operations/deepText.js";
 
 describe("deepText", () => {
-  test("joins strings and values together", async () => {
-    const array = [1, 2, 3];
-    const object = { person1: "Alice", person2: "Bob" };
-    const result = await deepText`a ${array} b ${object} c`;
-    assert.equal(result, "a 123 b AliceBob c");
+  test("concatenates deep tree values", async () => {
+    const tree = Tree.from({
+      a: "A",
+      b: "B",
+      c: "C",
+      more: {
+        d: "D",
+        e: "E",
+      },
+    });
+    const result = await deepText(tree);
+    assert.equal(result, "ABCDE");
+  });
+
+  test("concatenates deep tree-like values", async () => {
+    const letters = ["a", "b", "c"];
+    const specimens = new FunctionTree(
+      (letter) => ({
+        lowercase: letter,
+        uppercase: letter.toUpperCase(),
+      }),
+      letters
+    );
+    const result = await deepText(specimens);
+    assert.equal(result, "aAbBcC");
   });
 });

package/test/operations/text.test.js

@@ -0,0 +1,12 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import text from "../../src/operations/text.js";
+
+describe("text template literal function", () => {
+  test("joins strings and values together", async () => {
+    const array = [1, 2, 3];
+    const object = { person1: "Alice", person2: "Bob" };
+    const result = await text`a ${array} b ${object} c`;
+    assert.equal(result, "a 123 b AliceBob c");
+  });
+});

package/src/operations/concat.js

@@ -1,29 +0,0 @@
-import { assertIsTreelike, toString } from "../utilities.js";
-import deepValuesIterator from "./deepValuesIterator.js";
-
-/**
- * Concatenate the deep text values in a tree.
- *
- * @param {import("../../index.ts").Treelike} treelike
- */
-export default async function concat(treelike) {
-  assertIsTreelike(treelike, "concat");
-
-  const strings = [];
-  for await (const value of deepValuesIterator(treelike, { expand: true })) {
-    let string;
-    if (value === null) {
-      string = "null";
-    } else if (value === undefined) {
-      string = "undefined";
-    } else {
-      string = toString(value);
-    }
-    if (value === null || value === undefined) {
-      const message = `Warning: Origami template encountered a ${string} value. To locate where this happened, build your project and search your build output for the text "${string}".`;
-      console.warn(message);
-    }
-    strings.push(string);
-  }
-  return strings.join("");
-}

package/test/operations/concat.test.js

@@ -1,34 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import FunctionTree from "../../src/drivers/FunctionTree.js";
-import { Tree } from "../../src/internal.js";
-import concat from "../../src/operations/concat.js";
-
-describe("concat", () => {
-  test("concatenates deep tree values", async () => {
-    const tree = Tree.from({
-      a: "A",
-      b: "B",
-      c: "C",
-      more: {
-        d: "D",
-        e: "E",
-      },
-    });
-    const result = await concat.call(null, tree);
-    assert.equal(result, "ABCDE");
-  });
-
-  test("concatenates deep tree-like values", async () => {
-    const letters = ["a", "b", "c"];
-    const specimens = new FunctionTree(
-      (letter) => ({
-        lowercase: letter,
-        uppercase: letter.toUpperCase(),
-      }),
-      letters
-    );
-    const result = await concat.call(null, specimens);
-    assert.equal(result, "aAbBcC");
-  });
-});