@weborigami/async-tree 0.4.2 → 0.5.0

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "dependencies": {
-    "@weborigami/types": "0.4.2"
+    "@weborigami/types": "0.5.0"
   },
   "devDependencies": {
-    "@types/node": "22.13.13",
-    "puppeteer": "24.6.1",
-    "typescript": "5.8.2"
+    "@types/node": "24.3.0",
+    "puppeteer": "24.17.0",
+    "typescript": "5.9.2"
   },
   "scripts": {
     "headlessTest": "node test/browser/headlessTest.js",

package/shared.js

@@ -22,8 +22,11 @@ export { default as deepValues } from "./src/operations/deepValues.js";
 export { default as deepValuesIterator } from "./src/operations/deepValuesIterator.js";
 export { default as extensionKeyFunctions } from "./src/operations/extensionKeyFunctions.js";
 export { default as filter } from "./src/operations/filter.js";
+export { default as globKeys } from "./src/operations/globKeys.js";
 export { default as group } from "./src/operations/group.js";
+export { default as indent } from "./src/operations/indent.js";
 export { default as invokeFunctions } from "./src/operations/invokeFunctions.js";
+export { default as json } from "./src/operations/json.js";
 export { default as map } from "./src/operations/map.js";
 export { default as mask } from "./src/operations/mask.js";
 export { default as merge } from "./src/operations/merge.js";

package/src/drivers/ObjectTree.js

@@ -56,8 +56,14 @@ export default class ObjectTree {
 
     setParent(value, this);
 
-    if (typeof value === "function" && !Object.hasOwn(this.object, key)) {
-      // Value is an inherited method; bind it to the object.
+    // Is value an instance method? The first clause sees if the object is a
+    // constructor, in which case the method is likely a static method.
+    const isInstanceMethod =
+      !(this.object instanceof Function) &&
+      value instanceof Function &&
+      !Object.hasOwn(this.object, key);
+    if (isInstanceMethod) {
+      // Bind it to the object
       value = value.bind(this.object);
     }
 

package/src/operations/indent.js

@@ -0,0 +1,120 @@
+import { deepText, toString, Tree } from "@weborigami/async-tree";
+
+const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
+
+const mapStringsToModifications = new Map();
+
+/**
+ * Normalize indentation in a tagged template string
+ *
+ * @param {TemplateStringsArray} strings
+ * @param  {...any} values
+ * @returns {Promise<string>}
+ */
+export default async function indent(strings, ...values) {
+  let modified = mapStringsToModifications.get(strings);
+  if (!modified) {
+    modified = modifyStrings(strings);
+    mapStringsToModifications.set(strings, modified);
+  }
+  const { blockIndentations, strings: modifiedStrings } = modified;
+  const valueTexts = await Promise.all(
+    values.map((value) => (Tree.isTreelike(value) ? deepText(value) : value))
+  );
+  return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
+}
+
+// Join strings and values, applying the given block indentation to the lines of
+// values for block placholders.
+function joinBlocks(strings, values, blockIndentations) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    let text = toString(values[i]);
+    if (text) {
+      const blockIndentation = blockIndentations[i];
+      if (blockIndentation) {
+        const lines = text.split("\n");
+        text = "";
+        if (lines.at(-1) === "") {
+          // Drop empty last line
+          lines.pop();
+        }
+        for (let line of lines) {
+          text += blockIndentation + line + "\n";
+        }
+      }
+      result += text;
+    }
+    result += strings[i + 1];
+  }
+  return result;
+}
+
+// Given an array of template boilerplate strings, return an object { modified,
+// blockIndentations } where `strings` is the array of strings with indentation
+// removed, and `blockIndentations` is an array of indentation strings for each
+// block placeholder.
+function modifyStrings(strings) {
+  // Phase one: Identify the indentation based on the first real line of the
+  // first string (skipping the initial newline), and remove this indentation
+  // from all lines of all strings.
+  let indent;
+  if (strings.length > 0 && strings[0].startsWith("\n")) {
+    // Look for indenttation
+    const firstLineWhitespaceRegex = /^\n(?<indent>[ \t]*)/;
+    const match = strings[0].match(firstLineWhitespaceRegex);
+    indent = match?.groups.indent;
+  }
+
+  // Determine the modified strings. If this invoked as a JS tagged template
+  // literal, the `strings` argument will be an odd array-ish object that we'll
+  // want to convert to a real array.
+  let modified;
+  if (indent) {
+    // De-indent the strings.
+    const indentationRegex = new RegExp(`\n${indent}`, "g");
+    // The `replaceAll` also converts strings to a real array.
+    modified = strings.map((string) =>
+      string.replaceAll(indentationRegex, "\n")
+    );
+    // Remove indentation from last line of last string
+    modified[modified.length - 1] = modified
+      .at(-1)
+      .replace(lastLineWhitespaceRegex, "\n");
+  } else {
+    // No indentation; just copy the strings so we have a real array
+    modified = strings.slice();
+  }
+
+  // Phase two: Identify any block placholders, identify and remove their
+  // preceding indentation, and remove the following newline. Work backward from
+  // the end towards the start because we're modifying the strings in place and
+  // our pattern matching won't work going forward from start to end.
+  let blockIndentations = [];
+  for (let i = modified.length - 2; i >= 0; i--) {
+    // Get the modified before and after substitution with index `i`
+    const beforeString = modified[i];
+    const afterString = modified[i + 1];
+    const match = beforeString.match(lastLineWhitespaceRegex);
+    if (match && afterString.startsWith("\n")) {
+      // The substitution between these strings is a block substitution
+      let blockIndentation = match.groups.indent;
+      blockIndentations[i] = blockIndentation;
+      // Trim the before and after strings
+      if (blockIndentation) {
+        modified[i] = beforeString.slice(0, -blockIndentation.length);
+      }
+      modified[i + 1] = afterString.slice(1);
+    }
+  }
+
+  // Remove newline from start of first string *after* removing indentation.
+  if (modified[0].startsWith("\n")) {
+    modified[0] = modified[0].slice(1);
+  }
+
+  return {
+    blockIndentations,
+    strings: modified,
+  };
+}

package/src/operations/json.js

@@ -0,0 +1,20 @@
+/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
+import { Tree } from "../internal.js";
+import { isUnpackable, toPlainValue } from "../utilities.js";
+
+/**
+ * Render the given tree in JSON format.
+ *
+ * @param {import("../../index.ts").Treelike} [treelike]
+ */
+export default async function json(treelike) {
+  let tree = Tree.from(treelike);
+  if (tree === undefined) {
+    return undefined;
+  }
+  if (isUnpackable(tree)) {
+    tree = await tree.unpack();
+  }
+  const value = await toPlainValue(tree);
+  return JSON.stringify(value, null, 2);
+}

package/test/operations/indent.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import indent from "../../src/operations/indent.js";
+
+describe("taggedTemplateIndent", () => {
+  test("joins strings and values together if template isn't a block template", async () => {
+    const result = await indent`a ${"b"} c`;
+    assert.equal(result, "a b c");
+  });
+
+  test("removes first and last lines if template is a block template", async () => {
+    const actual = await indent`
+    <p>
+      Hello, ${"Alice"}!
+    </p>
+    `;
+    const expected = `
+<p>
+  Hello, Alice!
+</p>
+`.trimStart();
+    assert.equal(actual, expected);
+  });
+
+  test("indents all lines in a block substitution", async () => {
+    const lines = `
+Line 1
+Line 2
+Line 3`.trimStart();
+    const actual = await indent`
+    <main>
+      ${lines}
+    </main>
+    `;
+    const expected = `
+<main>
+  Line 1
+  Line 2
+  Line 3
+</main>
+`.trimStart();
+    assert.equal(actual, expected);
+  });
+});

package/test/operations/json.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import json from "../../src/operations/json.js";
+
+describe("json", () => {
+  test("renders a tree in JSON format", async () => {
+    const tree = Tree.from({ person1: "Alice", person2: "Bob" });
+    const result = await json(tree);
+    assert.equal(
+      result,
+      `{
+  "person1": "Alice",
+  "person2": "Bob"
+}`
+    );
+  });
+});