@weborigami/language 0.5.7 → 0.6.0

package/src/runtime/handleExtension.js

@@ -18,7 +18,7 @@ let projectGlobals;
  *
  * @param {any} value
  * @param {any} key
- * @param {import("@weborigami/types").AsyncTree} [parent]
+ * @param {import("@weborigami/async-tree").SyncOrAsyncMap} [parent]
  */
 export default async function handleExtension(value, key, parent) {
   projectGlobals ??= await globals();
@@ -28,13 +28,9 @@ export default async function handleExtension(value, key, parent) {
       key = trailingSlash.remove(key);
     }
 
-    // Special cases: `.ori.<ext>` extensions are Origami documents,
-    // `.jse.<ext>` are JSE documents.
-    // TODO: Remove .jse.<ext>
+    // Special cases: `.ori.<ext>` extensions are Origami documents
     const extname = key.match(/\.ori\.\S+$/)
       ? ".oridocument"
-      : key.match(/\.jse\.\S+$/)
-      ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
       const handlerName = `${extname.slice(1)}_handler`;

package/src/runtime/mergeTrees.js

@@ -3,14 +3,13 @@ import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
 /**
  * Create a tree that's the result of merging the given trees.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {(Treelike|null)[]} trees
+ * @param {(Maplike|null)[]} trees
  */
 export default async function mergeTrees(...trees) {
   // Filter out null or undefined trees.
-  /** @type {Treelike[]}
+  /** @type {Maplike[]}
    * @ts-ignore */
   const filtered = trees.filter((tree) => tree);
 
@@ -27,9 +26,7 @@ export default async function mergeTrees(...trees) {
   );
 
   // If all trees are plain objects, return a plain object.
-  if (
-    unpacked.every((tree) => isPlainObject(tree) && !Tree.isAsyncTree(tree))
-  ) {
+  if (unpacked.every((tree) => isPlainObject(tree) && !Tree.isMap(tree))) {
     // If we do an Object.assign, we'd evaluate getters.
     // To avoid that, we'll merge property descriptors.
     const result = {};

package/src/runtime/ops.js

@@ -1,17 +1,17 @@
 /**
  * @typedef {import("../../index.ts").AnnotatedCode} AnnotatedCode
- * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("../../index.ts").RuntimeState} RuntimeState
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  */
 
-import { isUnpackable, symbols, Tree } from "@weborigami/async-tree";
+import { getParent, isUnpackable, Tree } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
-import OrigamiFiles from "./OrigamiFiles.js";
+import OrigamiFileMap from "./OrigamiFileMap.js";
 import { codeSymbol } from "./symbols.js";
 
 function addOpLabel(op, label) {
@@ -176,7 +176,7 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  * Files tree for the user's home directory.
  */
 export async function homeDirectory(...keys) {
-  const tree = new OrigamiFiles(os.homedir());
+  const tree = new OrigamiFileMap(os.homedir());
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
@@ -196,7 +196,7 @@ export async function inherited(depth, state) {
         `Origami internal error: Can't find context object`
       );
     }
-    current = current.parent ?? current[symbols.parent];
+    current = getParent(current);
   }
   return current;
 }
@@ -406,11 +406,11 @@ export async function params(depth, state = {}) {
 addOpLabel(params, "«ops.params»");
 params.needsState = true;
 
-// export function optionalTraverse(treelike, key) {
-//   if (!treelike) {
+// export function optionalTraverse(maplike, key) {
+//   if (!maplike) {
 //     return undefined;
 //   }
-//   return Tree.traverseOrThrow(treelike, key);
+//   return Tree.traverseOrThrow(maplike, key);
 // }
 // addOpLabel(optionalTraverse, "«ops.optionalTraverse");
 
@@ -436,7 +436,7 @@ export async function property(object, key) {
   if (key in object) {
     // Object defines the property, get it
     let value = object[key];
-    // Is value an instance method? Copied from ObjectTree.
+    // Is value an instance method? Copied from ObjectMap.
     const isInstanceMethod =
       value instanceof Function && !Object.hasOwn(object, key);
     if (isInstanceMethod) {
@@ -460,7 +460,7 @@ addOpLabel(remainder, "«ops.remainder»");
  * Files tree for the filesystem root.
  */
 export async function rootDirectory(...keys) {
-  const tree = new OrigamiFiles("/");
+  const tree = new OrigamiFileMap("/");
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
@@ -468,7 +468,7 @@ addOpLabel(rootDirectory, "«ops.rootDirectory»");
 /**
  * Return the scope of the current tree
  *
- * @param {AsyncTree} parent
+ * @param {SyncOrAsyncMap} parent
  */
 export async function scope(parent) {
   if (!parent) {

package/test/cases/logicalAndExpression.yaml

@@ -108,14 +108,13 @@
   expected: false
   description: "Complex nesting with false at inner-most"
 
-# TODO: Uncomment when we can do math
-# - source: "true && (1 + 1 === 2)"
-#   expected: true
-#   description: "Combines logical AND with equality comparison"
-
-# - source: "false && (5 > 2)"
-#   expected: false
-#   description: "Logical AND with greater-than comparison"
+- source: "true && (1 + 1 === 2)"
+  expected: true
+  description: "Combines logical AND with equality comparison"
+
+- source: "false && (5 > 2)"
+  expected: false
+  description: "Logical AND with greater-than comparison"
 
 - source: "true && (3 || 0)"
   expected: 3

package/test/compiler/compile.test.js

@@ -130,7 +130,7 @@ async function assertCompile(text, expected, options = {}) {
   const parent = options.target ?? null;
   const fn = compile.expression(text, { globals, mode, parent });
   let result = await fn();
-  if (Tree.isTreelike(result)) {
+  if (Tree.isMaplike(result)) {
     result = await Tree.plain(result);
   }
   assert.deepEqual(result, expected);

package/test/compiler/optimize.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { SyncMap } from "@weborigami/async-tree";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import {
@@ -313,7 +313,7 @@ describe("optimize", () => {
 });
 
 function assertCompile(expression, expected, mode = "shell") {
-  const parent = new ObjectTree({});
+  const parent = new SyncMap();
   const globals = {};
   const fn = compile.expression(expression, { globals, mode, parent });
   const actual = fn.code;

package/test/generated/logicalAndExpression.test.js

@@ -33,6 +33,8 @@ describe("logicalAndExpression - JavaScript", () => {
   assert.strictEqual((true && true) && true, true, "Nested logical ANDs with all true");
   assert.strictEqual(true && (true && false), false, "Nested logical ANDs with false in inner");
   assert.strictEqual((true && (false && true)), false, "Complex nesting with false at inner-most");
+  assert.strictEqual(true && (1 + 1 === 2), true, "Combines logical AND with equality comparison");
+  assert.strictEqual(false && (5 > 2), false, "Logical AND with greater-than comparison");
   assert.strictEqual(true && (3 || 0), 3, "Logical AND with logical OR");
   assert.strictEqual(true && (0 || 3), 3, "Logical AND with logical OR and falsy values");
   assert.strictEqual('' && false, "", "Falsy string and false");
@@ -70,6 +72,8 @@ describe("logicalAndExpression - Origami", async() => {
   assert.strictEqual(await oriEval("(true && true) && true"), true, "Nested logical ANDs with all true");
   assert.strictEqual(await oriEval("true && (true && false)"), false, "Nested logical ANDs with false in inner");
   assert.strictEqual(await oriEval("(true && (false && true))"), false, "Complex nesting with false at inner-most");
+  assert.strictEqual(await oriEval("true && (1 + 1 === 2)"), true, "Combines logical AND with equality comparison");
+  assert.strictEqual(await oriEval("false && (5 > 2)"), false, "Logical AND with greater-than comparison");
   assert.strictEqual(await oriEval("true && (3 || 0)"), 3, "Logical AND with logical OR");
   assert.strictEqual(await oriEval("true && (0 || 3)"), 3, "Logical AND with logical OR and falsy values");
   assert.strictEqual(await oriEval("'' && false"), "", "Falsy string and false");

package/test/handlers/{csv.handler.test.js → csv_handler.test.js}

@@ -10,17 +10,17 @@ Bob,25,Los Angeles
 "Carol ""CJ""",22,Chicago`;
     const result = csv_handler.unpack(csvText);
     assert.deepStrictEqual(result, [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
-      { name: 'Carol "CJ"', age: "22", city: "Chicago" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
+      { name: 'Carol "CJ"', age: 22, city: "Chicago" },
     ]);
   });
 
   test("handles CRLF line endings", () => {
     const textCRLF = `name,age,city\r\nAlice,30,"New York, NY"\r\nBob,25,Los Angeles\r\n`;
     const expected = [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
     ];
     const result = csv_handler.unpack(textCRLF);
     assert.deepStrictEqual(result, expected);

package/test/handlers/{js.handler.test.js → js_handler.test.js}

@@ -1,11 +1,11 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import js_handler from "../../src/handlers/js_handler.js";
 import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+const fixturesTree = new (ImportModulesMixin(FileMap))(fixturesUrl);
 
 describe(".js handler", () => {
   test("loads .js file that exports a string", async () => {

package/test/handlers/{ori.handler.test.js → ori_handler.test.js}

@@ -1,11 +1,11 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import ori_handler from "../../src/handlers/ori_handler.js";
-import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixtures = new OrigamiFiles(fixturesUrl);
+const fixtures = new OrigamiFileMap(fixturesUrl);
 
 describe(".ori handler", async () => {
   test("loads a string expression", async () => {
@@ -15,7 +15,7 @@ describe(".ori handler", async () => {
   });
 
   test("loads a tree expression", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "world",
     });
     const source = `{
@@ -43,15 +43,15 @@ describe(".ori handler", async () => {
   });
 
   test("loads an object containing an object shorthand", async () => {
-    const assets = new ObjectTree({});
-    const parent = new ObjectTree({ assets });
+    const assets = new ObjectMap({});
+    const parent = new ObjectMap({ assets });
     const source = `{ assets }`;
     const object = await ori_handler.unpack(source, { parent });
     assert.equal(object.assets, assets);
   });
 
   test("loads a template literal", async () => {
-    const scope = new ObjectTree({
+    const scope = new ObjectMap({
       name: "Alice",
     });
     const source = `\`Hello, \${name}!\``;
@@ -62,7 +62,7 @@ describe(".ori handler", async () => {
   });
 
   test("loads a template lambda that reads from parent scope", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "Alice",
     });
     const source = `() => \`Hello, \${name}!\``;

package/test/handlers/{oridocument.handler.test.js → oridocument_handler.test.js}

@@ -1,11 +1,11 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import oridocument_handler from "../../src/handlers/oridocument_handler.js";
 
 describe("Origami document handler", () => {
   test("unpacks text with Origami expressions", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "world",
     });
     const text = "Hello, ${ name }!";
@@ -28,7 +28,7 @@ describe("Origami document handler", () => {
   });
 
   test("YAML front matter is returned with _body", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       message: "Hello",
     });
     const text = `---

package/test/handlers/sh_handler.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import sh_handler from "../../src/handlers/sh_handler.js";
+
+describe(".sh handler", () => {
+  test("invokes shell commands", async () => {
+    const text = `echo Hello
+  cat
+  `;
+    const fn = await sh_handler.unpack(text);
+    const output = await fn("Input text");
+    assert.equal(output, "Hello\nInput text");
+  });
+});

package/test/handlers/tsv_handler.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import tsv_handler from "../../src/handlers/tsv_handler.js";
+
+describe(".tsv handler", () => {
+  test("parses TSV text into array of objects", () => {
+    const TSVText = `name	age	city
+Alice\t30\tNew York, NY
+Bob\t25\tLos Angeles
+Carol\t22\tChicago`;
+    const result = tsv_handler.unpack(TSVText);
+    assert.deepStrictEqual(result, [
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
+      { name: "Carol", age: 22, city: "Chicago" },
+    ]);
+  });
+
+  test("handles CRLF line endings", () => {
+    const textCRLF = `name\tage\tcity\r\nAlice\t30\tNew York, NY\r\nBob\t25\tLos Angeles\r\n`;
+    const expected = [
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
+    ];
+    const result = tsv_handler.unpack(textCRLF);
+    assert.deepStrictEqual(result, expected);
+  });
+});

package/test/handlers/{wasm.handler.test.js → wasm_handler.test.js}

@@ -1,11 +1,11 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import wasm_handler from "../../src/handlers/wasm_handler.js";
 import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+const fixturesTree = new (ImportModulesMixin(FileMap))(fixturesUrl);
 
 describe(".wasm handler", () => {
   test("loads .wasm file that exports a function", async () => {

package/test/runtime/OrigamiFileMap.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import path from "node:path";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const tempDirectory = path.join(dirname, "fixtures/temp/OrigamiFileMap");
+
+describe("OrigamiFileMap", () => {
+  test.skip("can watch its folder for changes", { timeout: 2000 }, async () => {
+    createTempDirectory();
+
+    const tempFiles = new OrigamiFileMap(tempDirectory);
+    const changedFileName = await new Promise(async (resolve) => {
+      tempFiles.addEventListener("change", (event) => {
+        resolve(/** @type {any} */ (event).options.key);
+      });
+      tempFiles.set(
+        "foo.txt",
+        "This file is left over from testing and can be removed."
+      );
+    });
+    removeTempDirectory();
+    assert.equal(changedFileName, "foo.txt");
+  });
+});
+
+function createTempDirectory() {
+  // Remove any existing files or directories inside the temp directory so
+  // tests start from a clean slate. Use force so this is safe if the
+  // directory doesn't exist.
+  fs.rmSync(tempDirectory, { force: true, recursive: true });
+  fs.mkdirSync(tempDirectory, { recursive: true });
+}
+
+function removeTempDirectory() {
+  fs.rmSync(tempDirectory, { force: true, recursive: true });
+}

package/test/runtime/evaluate.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
-import { ObjectTree } from "@weborigami/async-tree";
+import { SyncMap } from "@weborigami/async-tree";
 import evaluate from "../../src/runtime/evaluate.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
@@ -27,12 +27,12 @@ describe("evaluate", () => {
   });
 
   test("if function has containerAsTarget, it gets bound to state.container", async () => {
-    /** @this {import("@weborigami/types").AsyncTree} */
+    /** @this {import("@weborigami/async-tree").SyncOrAsyncMap} */
     const fn = function () {
       return this;
     };
     fn.containerAsTarget = true;
-    const container = new ObjectTree({});
+    const container = new SyncMap();
     const state = { container };
     const code = createCode([fn]);
     const result = await evaluate(code, state);

package/test/runtime/expressionObject.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { ObjectMap, symbols, SyncMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -7,7 +7,7 @@ import { ops } from "../../src/runtime/internal.js";
 
 describe("expressionObject", () => {
   test("can instantiate an object", async () => {
-    const container = new ObjectTree({
+    const container = new ObjectMap({
       upper: (s) => s.toUpperCase(),
     });
 
@@ -15,7 +15,7 @@ describe("expressionObject", () => {
       ["hello", [[[ops.scope, container], "upper"], "hello"]],
       ["world", [[[ops.scope, container], "upper"], "world"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
 
     const object = await expressionObject(entries, { object: context });
     assert.equal(await object.hello, "HELLO");
@@ -43,7 +43,7 @@ describe("expressionObject", () => {
       ["name", "world"],
       ["message", [ops.concat, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const object = await expressionObject(entries, { object: context });
     assert.deepEqual(await Tree.plain(object), {
       name: "world",
@@ -54,7 +54,7 @@ describe("expressionObject", () => {
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const result = await expressionObject(entries, { object: context });
     const dataJson = await result["data.json"];
     const json = await dataJson.unpack();
@@ -77,7 +77,7 @@ describe("expressionObject", () => {
       ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
       ["hasSlash/", "This isn't really a tree but says it is"],
       ["message", "Hello"],
-      // Immediate treelike value, should have a slash
+      // Immediate maplike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
     ];
     const object = await expressionObject(entries);
@@ -88,4 +88,12 @@ describe("expressionObject", () => {
       "object/",
     ]);
   });
+
+  test("sets symbols.async on objects with getters", async () => {
+    const noGetter = await expressionObject([["eager", 1]]);
+    assert.equal(noGetter[symbols.async], undefined);
+
+    const hasGetter = await expressionObject([["lazy", [ops.getter, [2]]]]);
+    assert.equal(hasGetter[symbols.async], true);
+  });
 });

package/test/runtime/handleExtension.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import handleExtension from "../../src/runtime/handleExtension.js";
@@ -25,7 +25,7 @@ describe("handleExtension", () => {
 });
 
 function createFixture() {
-  return new ObjectTree({
+  return new ObjectMap({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });

package/test/runtime/mergeTrees.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
@@ -42,7 +42,7 @@ describe("mergeTrees", () => {
 
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees(
-      new ObjectTree({
+      new ObjectMap({
         a: 1,
         b: 2,
       }),

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, ObjectTree, Tree } from "@weborigami/async-tree";
+import { DeepObjectMap, ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -128,12 +128,12 @@ describe("ops", () => {
       assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
     });
 
-    test("flattens treelike objects", async () => {
+    test("flattens maplike objects", async () => {
       const object = {
         a: 1,
         b: 2,
       };
-      const tree = new ObjectTree({
+      const tree = new ObjectMap({
         c: 3,
         d: 4,
       });
@@ -156,7 +156,7 @@ describe("ops", () => {
   });
 
   test("ops.inherited walks up the object parent chain", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: {
         b: {},
       },
@@ -368,7 +368,7 @@ describe("ops", () => {
 
   describe("ops.scope", () => {
     test("returns the scope of the given tree", async () => {
-      const tree = new DeepObjectTree({
+      const tree = new DeepObjectMap({
         a: {
           b: {},
         },

package/src/runtime/InvokeFunctionsTransform.d.ts

@@ -1,5 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-declare const InvokeFunctionsTransform: Mixin<{}>;
-
-export default InvokeFunctionsTransform;

package/src/runtime/InvokeFunctionsTransform.js

@@ -1,25 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function InvokeFunctionsTransform(Base) {
-  return class InvokeFunctions extends Base {
-    async get(key) {
-      let value = await super.get(key);
-      if (typeof value === "function") {
-        value = await value();
-
-        if (Tree.isAsyncTree(value) && !value.parent) {
-          value.parent = this;
-        }
-      }
-      return value;
-    }
-  };
-}

package/src/runtime/functionResultsMap.js

@@ -1,17 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- */
-export default async function functionResultsMap(treelike) {
-  return Tree.map(treelike, {
-    description: "functionResultsMap",
-
-    value: async (sourceValue, sourceKey, tree) => {
-      const resultValue =
-        typeof sourceValue === "function" ? await sourceValue() : sourceValue;
-      return resultValue;
-    },
-  });
-}