@weborigami/language 0.2.11 → 0.2.12

package/main.js

@@ -14,7 +14,6 @@ export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctio
 export * as moduleCache from "./src/runtime/moduleCache.js";
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
 export * as symbols from "./src/runtime/symbols.js";
-export { default as taggedTemplate } from "./src/runtime/taggedTemplate.js";
 export { default as taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.11",
-    "@weborigami/types": "0.2.11",
+    "@weborigami/async-tree": "0.2.12",
+    "@weborigami/types": "0.2.12",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/parserHelpers.js

@@ -226,7 +226,13 @@ export function makeCall(target, args) {
     }
   } else if (args[0] === ops.template) {
     // Tagged template
-    fnCall = [upgradeReference(target), ...args.slice(1)];
+    const strings = args[1];
+    const values = args.slice(2);
+    fnCall = makeTaggedTemplateCall(
+      upgradeReference(target),
+      strings,
+      ...values
+    );
   } else {
     // Function call with explicit or implicit parentheses
     fnCall = [upgradeReference(target), ...args];
@@ -373,6 +379,24 @@ export function makeReference(identifier) {
   return [op, identifier];
 }
 
+/**
+ * Make a tagged template call
+ *
+ * Because the tagged template function may not be an Origami function, we wrap
+ * each argument in a ops.concat call to convert it to a string.
+ *
+ * @param {AnnotatedCode} fn
+ * @param {AnnotatedCode} strings
+ * @param {AnnotatedCode[]} values
+ */
+function makeTaggedTemplateCall(fn, strings, ...values) {
+  const args = values.map((value) =>
+    // @ts-ignore
+    annotate([ops.concat, value], value.location)
+  );
+  return annotate([fn, strings, ...args], strings.location);
+}
+
 /**
  * Make a template
  *
@@ -385,8 +409,7 @@ export function makeTemplate(op, head, tail, location) {
   const strings = [head[1]];
   const values = [];
   for (const [value, literal] of tail) {
-    const concat = annotate([ops.concat, value], value.location);
-    values.push(concat);
+    values.push(value);
     strings.push(literal[1]);
   }
   const stringsCode = annotate(strings, location);

package/src/runtime/ops.js

@@ -8,6 +8,7 @@
 import {
   ObjectTree,
   Tree,
+  concatTrees,
   isUnpackable,
   scope as scopeFn,
   symbols,
@@ -21,7 +22,6 @@ import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import { codeSymbol } from "./symbols.js";
-import taggedTemplate from "./taggedTemplate.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -532,15 +532,15 @@ addOpLabel(subtraction, "«ops.subtraction»");
 /**
  * Apply the default tagged template function.
  */
-export function template(strings, ...values) {
-  return taggedTemplate(strings, ...values);
+export async function template(strings, ...values) {
+  return concatTrees(strings, ...values);
 }
 addOpLabel(template, "«ops.template»");
 
 /**
  * Apply the tagged template indent function.
  */
-export function templateIndent(strings, ...values) {
+export async function templateIndent(strings, ...values) {
   return taggedTemplateIndent(strings, ...values);
 }
 addOpLabel(templateIndent, "«ops.templateIndent");

package/src/runtime/taggedTemplateIndent.js

@@ -1,22 +1,27 @@
+import { concat, toString, Tree } from "@weborigami/async-tree";
+
 const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
 
 const mapStringsToModifications = new Map();
 
 /**
- * Normalize indentation in a tagged template string.
+ * Normalize indentation in a tagged template string
  *
  * @param {TemplateStringsArray} strings
  * @param  {...any} values
- * @returns {string}
+ * @returns {Promise<string>}
  */
-export default function indent(strings, ...values) {
+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;
-  return joinBlocks(modifiedStrings, values, blockIndentations);
+  const valueTexts = await Promise.all(
+    values.map((value) => (Tree.isTreelike(value) ? concat(value) : value))
+  );
+  return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }
 
 // Join strings and values, applying the given block indentation to the lines of
@@ -24,7 +29,7 @@ export default function indent(strings, ...values) {
 function joinBlocks(strings, values, blockIndentations) {
   let result = strings[0];
   for (let i = 0; i < values.length; i++) {
-    let text = values[i];
+    let text = toString(values[i]);
     if (text) {
       const blockIndentation = blockIndentations[i];
       if (blockIndentation) {

package/test/compiler/parse.test.js

@@ -298,7 +298,7 @@ describe("Origami parser", () => {
     assertThrows("templateLiteral", "`foo", "Expected closing backtick");
   });
 
-  test.only("error thrown for invalid Origami front matter expression", () => {
+  test("error thrown for invalid Origami front matter expression", () => {
     assertThrows(
       "templateDocument",
       `---
@@ -446,11 +446,7 @@ Body`,
       [
         ops.lambda,
         [[ops.literal, "_"]],
-        [
-          ops.template,
-          [ops.literal, ["<li>", "</li>"]],
-          [ops.concat, [ops.scope, "_"]],
-        ],
+        [ops.template, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
       ],
     ]);
     assertParse("expression", `https://example.com/about/`, [
@@ -991,11 +987,7 @@ Body`,
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [
-        ops.template,
-        [ops.literal, ["Hello, ", "."]],
-        [ops.concat, [ops.scope, "name"]],
-      ],
+      [ops.template, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
@@ -1037,7 +1029,7 @@ Body`,
       [
         ops.templateIndent,
         [ops.literal, ["hello", "world"]],
-        [ops.concat, [ops.scope, "foo"]],
+        [ops.scope, "foo"],
       ],
     ]);
     assertParse("templateBody", "Documents can contain ` backticks", [
@@ -1100,7 +1092,7 @@ Body text`,
               [
                 ops.templateIndent,
                 [ops.literal, ["<h1>", "</h1>\n"]],
-                [ops.concat, [ops.scope, "title"]],
+                [ops.scope, "title"],
               ],
             ],
             undefined,
@@ -1118,30 +1110,23 @@ Body text`,
     assertParse("templateLiteral", "`foo ${x} bar`", [
       ops.template,
       [ops.literal, ["foo ", " bar"]],
-      [ops.concat, [ops.scope, "x"]],
+      [ops.scope, "x"],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
       ops.template,
       [ops.literal, ["", ""]],
-      [ops.concat, [ops.template, [ops.literal, ["nested"]]]],
+      [ops.template, [ops.literal, ["nested"]]],
     ]);
     assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
       ops.template,
       [ops.literal, ["", ""]],
       [
-        ops.concat,
+        [ops.builtin, "map:"],
+        [ops.scope, "people"],
         [
-          [ops.builtin, "map:"],
-          [ops.scope, "people"],
-          [
-            ops.lambda,
-            [[ops.literal, "_"]],
-            [
-              ops.template,
-              [ops.literal, ["", ""]],
-              [ops.concat, [ops.scope, "name"]],
-            ],
-          ],
+          ops.lambda,
+          [[ops.literal, "_"]],
+          [ops.template, [ops.literal, ["", ""]], [ops.scope, "name"]],
         ],
       ],
     ]);

package/test/runtime/expressionObject.test.js

@@ -5,7 +5,7 @@ import { describe, test } from "node:test";
 import expressionObject from "../../src/runtime/expressionObject.js";
 import { ops } from "../../src/runtime/internal.js";
 
-describe.only("expressionObject", () => {
+describe("expressionObject", () => {
   test("can instantiate an object", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),
@@ -74,7 +74,7 @@ describe.only("expressionObject", () => {
     assert.equal(object["hidden"], "shh");
   });
 
-  test.only("provides a symbols.keys method", async () => {
+  test("provides a symbols.keys method", async () => {
     const entries = [
       // Will return a tree, should have a slash
       ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],

package/test/runtime/taggedTemplateIndent.test.js

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

package/src/runtime/taggedTemplate.js

@@ -1,9 +0,0 @@
-// Default JavaScript tagged template function splices strings and values
-// together.
-export default function taggedTemplate(strings, ...values) {
-  let result = strings[0];
-  for (let i = 0; i < values.length; i++) {
-    result += values[i] + strings[i + 1];
-  }
-  return result;
-}

package/test/runtime/taggedTemplate.test.js

@@ -1,10 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import taggedTemplate from "../../src/runtime/taggedTemplate.js";
-
-describe("taggedTemplate", () => {
-  test("joins strings and values together", () => {
-    const result = taggedTemplate`a ${"b"} c`;
-    assert.equal(result, "a b c");
-  });
-});