@weborigami/language 0.0.38 → 0.0.40

package/src/runtime/FileLoadersTransform.js

@@ -32,7 +32,7 @@ export default function FileLoadersTransform(Base) {
             value = new String(input);
             const parent = this;
             value.parent = parent;
-            value.unpack = () => unpackFn(input, { key, parent });
+            value.unpack = unpackFn.bind(null, input, { key, parent });
           }
         }
       }

package/src/runtime/concatTreeValues.js

@@ -1,4 +1,8 @@
-import { Tree, getRealmObjectPrototype } from "@weborigami/async-tree";
+import {
+  Tree,
+  getRealmObjectPrototype,
+  isPlainObject,
+} from "@weborigami/async-tree";
 
 /**
  * Concatenate the text values in a tree.
@@ -24,6 +28,22 @@ async function getText(value, scope) {
     value = await value.call(scope);
   }
 
+  // We'd prefer to use Tree.isTreelike() here, but that counts an object with
+  // an unpack() function as a treelike object. In this case, we don't want to
+  // unpack anything that's not already treelike.
+  const isTreelike =
+    Tree.isAsyncTree(value) ||
+    value instanceof Function ||
+    value instanceof Array ||
+    value instanceof Set ||
+    isPlainObject(value);
+  if (isTreelike) {
+    // The mapReduce operation above only implicit casts its top-level input to
+    // a tree. If we're asked for the text of a treelike value, we need to
+    // explicitly recurse.
+    return concatTreeValues.call(scope, value);
+  }
+
   // Convert to text, preferring .toString but avoiding dumb Object.toString.
   // Exception: if the result is an array, we'll concatenate the values.
   let text;

package/src/runtime/ops.js

@@ -10,6 +10,9 @@ import Scope from "./Scope.js";
 import concatTreeValues from "./concatTreeValues.js";
 import { OrigamiTree, evaluate, expressionFunction } from "./internal.js";
 
+// For memoizing lambda functions
+const lambdaFnMap = new Map();
+
 /**
  * Construct an array.
  *
@@ -130,6 +133,9 @@ inherited.toString = () => "«ops.inherited»";
  * @param {Code} code
  */
 export function lambda(code) {
+  if (lambdaFnMap.has(code)) {
+    return lambdaFnMap.get(code);
+  }
   /** @this {AsyncTree|null} */
   async function invoke(input) {
     // Add ambients to scope.
@@ -142,6 +148,7 @@ export function lambda(code) {
     return result;
   }
   invoke.code = code;
+  lambdaFnMap.set(code, invoke);
   return invoke;
 }
 lambda.toString = () => "«ops.lambda»";
@@ -182,7 +189,9 @@ export async function tree(...entries) {
     return [key, value];
   });
   const object = Object.fromEntries(fns);
-  return new OrigamiTree(object);
+  const result = new OrigamiTree(object);
+  result.scope = new Scope(result, this);
+  return result;
 }
 tree.toString = () => "«ops.tree»";
 

package/test/compiler/parse.test.js

@@ -93,7 +93,7 @@ describe("Origami parser", () => {
       "expression",
       `
         {
-          index.html = index.orit(teamData.yaml)
+          index.html = index.ori(teamData.yaml)
           thumbnails = @map(images, { valueMap: thumbnail.js })
         }
       `,
@@ -102,7 +102,7 @@ describe("Origami parser", () => {
         [
           "index.html",
           [
-            [ops.scope, "index.orit"],
+            [ops.scope, "index.ori"],
             [ops.scope, "teamData.yaml"],
           ],
         ],

package/test/runtime/InheritScopeMixin.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { DeepObjectTree, ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import InheritScopeMixin from "../../src/runtime/InheritScopeMixin.js";
@@ -16,7 +16,7 @@ describe("InheritScopeMixin", () => {
   });
 
   test("adds a subtree's parent to the subtrees's scope", async () => {
-    const fixture = new (InheritScopeMixin(ObjectTree))({
+    const fixture = new (InheritScopeMixin(DeepObjectTree))({
       a: 1,
       subtree: {
         b: 2,

package/test/runtime/{concatTreeValues.js → concatTreeValues.test.js}

@@ -1,4 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
+import { FunctionTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import concatTreeValues from "../../src/runtime/concatTreeValues.js";
@@ -17,4 +17,17 @@ describe("concatTreeValues", () => {
     const result = await concatTreeValues.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 concatTreeValues.call(null, specimens);
+    assert.equal(result, "aAbBcC");
+  });
 });