@weborigami/language 0.3.3-jse.2 → 0.3.3

package/src/compiler/parserHelpers.js

@@ -204,8 +204,7 @@ export function makeCall(target, args) {
   }
 
   let fnCall;
-  const op = args[0];
-  if (op === ops.traverse || op === ops.optionalTraverse) {
+  if (args[0] === ops.traverse) {
     let tree = target;
 
     if (tree[0] === undetermined) {
@@ -220,12 +219,12 @@ export function makeCall(target, args) {
     if (args.length > 1) {
       // Regular traverse
       const keys = args.slice(1);
-      fnCall = [op, tree, ...keys];
+      fnCall = [ops.traverse, tree, ...keys];
     } else {
       // Traverse without arguments equates to unpack
       fnCall = [ops.unpack, tree];
     }
-  } else if (op === ops.templateStandard || op === ops.templateTree) {
+  } else if (args[0] === ops.template) {
     // Tagged template
     const strings = args[1];
     const values = args.slice(2);
@@ -276,15 +275,6 @@ export function makeDeferredArguments(args) {
   });
 }
 
-export function makeJsPropertyAccess(expression, property) {
-  const location = {
-    source: expression.location.source,
-    start: expression.location.start,
-    end: property.location.end,
-  };
-  return annotate([expression, property], location);
-}
-
 /**
  * Make an object.
  *
@@ -374,6 +364,15 @@ export function makeProperty(key, value) {
   return [key, modified];
 }
 
+export function makeJsPropertyAccess(expression, property) {
+  const location = {
+    source: expression.location.source,
+    start: expression.location.start,
+    end: property.location.end,
+  };
+  return annotate([expression, property], location);
+}
+
 export function makeReference(identifier) {
   // We can't know for sure that an identifier is a builtin reference until we
   // see whether it's being called as a function.

package/src/runtime/handlers.js

@@ -74,12 +74,9 @@ export async function handleExtension(parent, value, key) {
       key = trailingSlash.remove(key);
     }
 
-    // Special cases: `.ori.<ext>` extensions are Origami documents,
-    // `.jse.<ext>` are JSE documents.
+    // Special case: `.ori.<ext>` extensions are Origami documents.
     const extname = key.match(/\.ori\.\S+$/)
       ? ".oridocument"
-      : key.match(/\.jse\.\S+$/)
-      ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
       const handler = await getExtensionHandler(parent, extname);

package/src/runtime/ops.js

@@ -12,17 +12,16 @@ import {
   isUnpackable,
   scope as scopeFn,
   setParent,
-  text as templateFunctionTree,
+  concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
+import taggedTemplateIndent from "../../src/runtime/taggedTemplateIndent.js";
 import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 import expressionObject from "./expressionObject.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import { codeSymbol } from "./symbols.js";
-import templateFunctionIndent from "./templateIndent.js";
-import templateFunctionStandard from "./templateStandard.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -106,7 +105,7 @@ addOpLabel(comma, "«ops.comma»");
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return deepText.call(this, args);
+  return treeConcat.call(this, args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -115,13 +114,6 @@ export async function conditional(condition, truthy, falsy) {
   return value instanceof Function ? await value() : value;
 }
 
-export async function construct(constructor, ...args) {
-  if (isUnpackable(constructor)) {
-    constructor = await constructor.unpack();
-  }
-  return Reflect.construct(constructor, args);
-}
-
 /**
  * Construct a document object by invoking the body code (a lambda) and adding
  * the resulting text to the front data.
@@ -480,14 +472,6 @@ export async function object(...entries) {
 addOpLabel(object, "«ops.object»");
 object.unevaluatedArgs = true;
 
-export function optionalTraverse(treelike, key) {
-  if (!treelike) {
-    return undefined;
-  }
-  return Tree.traverseOrThrow(treelike, key);
-}
-addOpLabel(optionalTraverse, "«ops.optionalTraverse");
-
 export function remainder(a, b) {
   return a % b;
 }
@@ -562,29 +546,21 @@ export function subtraction(a, b) {
 }
 addOpLabel(subtraction, "«ops.subtraction»");
 
-/**
- * Apply the tree indent tagged template function.
- */
-export async function templateIndent(strings, ...values) {
-  return templateFunctionIndent(strings, ...values);
-}
-addOpLabel(templateIndent, "«ops.templateIndent»");
-
 /**
  * Apply the default tagged template function.
  */
-export function templateStandard(strings, ...values) {
-  return templateFunctionStandard(strings, ...values);
+export async function template(strings, ...values) {
+  return deepText(strings, ...values);
 }
-addOpLabel(templateStandard, "«ops.templateStandard»");
+addOpLabel(template, "«ops.template»");
 
 /**
- * Apply the tree tagged template function.
+ * Apply the tagged template indent function.
  */
-export async function templateTree(strings, ...values) {
-  return templateFunctionTree(strings, ...values);
+export async function templateIndent(strings, ...values) {
+  return taggedTemplateIndent(strings, ...values);
 }
-addOpLabel(templateTree, "«ops.templateTree»");
+addOpLabel(templateIndent, "«ops.templateIndent");
 
 /**
  * Traverse a path of keys through a tree.

package/src/runtime/{templateIndent.js → taggedTemplateIndent.js}

@@ -1,4 +1,4 @@
-import { deepText, toString, Tree } from "@weborigami/async-tree";
+import { concat, toString, Tree } from "@weborigami/async-tree";
 
 const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
 
@@ -19,7 +19,7 @@ export default async function indent(strings, ...values) {
   }
   const { blockIndentations, strings: modifiedStrings } = modified;
   const valueTexts = await Promise.all(
-    values.map((value) => (Tree.isTreelike(value) ? deepText(value) : value))
+    values.map((value) => (Tree.isTreelike(value) ? concat(value) : value))
   );
   return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }

package/test/compiler/parse.test.js

@@ -19,46 +19,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("angleBracketLiteral", () => {
-    assertParse(
-      "angleBracketLiteral",
-      "<index.html>",
-      [ops.scope, "index.html"],
-      "jse",
-      false
-    );
-    assertParse(
-      "angleBracketLiteral",
-      "<foo/bar/baz>",
-      [
-        ops.traverse,
-        [ops.scope, "foo/"],
-        [ops.literal, "bar/"],
-        [ops.literal, "baz"],
-      ],
-      "jse",
-      false
-    );
-    assertParse("angleBracketLiteral", "<files:src/assets>", [
-      ops.traverse,
-      [
-        [ops.builtin, "files:"],
-        [ops.literal, "src/"],
-      ],
-      [ops.literal, "assets"],
-    ]);
-    assertParse(
-      "angleBracketLiteral",
-      "<https://example.com/>",
-      [
-        [ops.builtin, "https:"],
-        [ops.literal, "example.com/"],
-      ],
-      "jse",
-      false
-    );
-  });
-
   test("arrayLiteral", () => {
     assertParse("arrayLiteral", "[]", [ops.array]);
     assertParse("arrayLiteral", "[1, 2, 3]", [
@@ -439,8 +399,7 @@ Body`,
     ]);
 
     // Consecutive slashes at start of something = comment
-    assertParse("expression", "x //comment", [ops.scope, "x"], "jse", false);
-
+    assertParse("expression", "path //comment", [ops.scope, "path"], false);
     assertParse("expression", "page.ori(mdHtml:(about.md))", [
       [ops.scope, "page.ori"],
       [
@@ -487,11 +446,7 @@ Body`,
     ]);
     assertParse("expression", "fn =`x`", [
       [ops.builtin, "fn"],
-      [
-        ops.lambda,
-        [[ops.literal, "_"]],
-        [ops.templateTree, [ops.literal, ["x"]]],
-      ],
+      [ops.lambda, [[ops.literal, "_"]], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expression", "copy app.js(formulas), files:snapshot", [
       [ops.builtin, "copy"],
@@ -509,7 +464,7 @@ Body`,
       [
         ops.lambda,
         [[ops.literal, "_"]],
-        [ops.templateTree, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
+        [ops.template, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
       ],
     ]);
     assertParse("expression", `https://example.com/about/`, [
@@ -568,23 +523,6 @@ Body`,
     ]);
   });
 
-  test("frontMatterExpression", () => {
-    assertParse(
-      "frontMatterExpression",
-      `---
-(name) => _template()
----
-`,
-      [
-        ops.lambda,
-        [[ops.literal, "name"]],
-        [[ops.scope, "_template"], undefined],
-      ],
-      "jse",
-      false
-    );
-  });
-
   test("group", () => {
     assertParse("group", "(hello)", [ops.scope, "hello"]);
     assertParse("group", "(((nested)))", [ops.scope, "nested"]);
@@ -606,10 +544,10 @@ Body`,
   });
 
   test("identifier", () => {
-    assertParse("identifier", "abc", "abc", "shell", false);
-    assertParse("identifier", "index.html", "index.html", "shell", false);
-    assertParse("identifier", "foo\\ bar", "foo bar", "shell", false);
-    assertParse("identifier", "x-y-z", "x-y-z", "shell", false);
+    assertParse("identifier", "abc", "abc", false);
+    assertParse("identifier", "index.html", "index.html", false);
+    assertParse("identifier", "foo\\ bar", "foo bar", false);
+    assertParse("identifier", "x-y-z", "x-y-z", false);
   });
 
   test("implicitParenthesesCallExpression", () => {
@@ -648,8 +586,8 @@ Body`,
   });
 
   test("jsIdentifier", () => {
-    assertParse("jsIdentifier", "foo", "foo", "jse", false);
-    assertParse("jsIdentifier", "$Δelta", "$Δelta", "jse", false);
+    assertParse("jsIdentifier", "foo", "foo", false);
+    assertParse("jsIdentifier", "$Δelta", "$Δelta", false);
     assertThrows(
       "jsIdentifier",
       "1stCharacterIsNumber",
@@ -689,7 +627,6 @@ Body`,
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
-    assertThrows("list", "1\n2\n3", `but "\\n" found`, 0, "jse");
     assertParse("list", "'a' , 'b' , 'c'", [
       [ops.literal, "a"],
       [ops.literal, "b"],
@@ -725,13 +662,7 @@ Body`,
   });
 
   test("multiLineComment", () => {
-    assertParse(
-      "multiLineComment",
-      "/*\nHello, world!\n*/",
-      null,
-      "jse",
-      false
-    );
+    assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
   test("multiplicativeExpression", () => {
@@ -756,13 +687,6 @@ Body`,
     assertParse("namespace", "js:", [ops.builtin, "js:"]);
   });
 
-  test("newExpression", () => {
-    assertParse("newExpression", "new Foo()", [
-      ops.construct,
-      [ops.scope, "Foo"],
-    ]);
-  });
-
   test("nullishCoalescingExpression", () => {
     assertParse("nullishCoalescingExpression", "a ?? b", [
       ops.nullishCoalescing,
@@ -915,16 +839,9 @@ Body`,
   });
 
   test("objectPublicKey", () => {
-    assertParse("objectPublicKey", "a", "a", "jse", false);
-    assertParse("objectPublicKey", "markdown/", "markdown/", "jse", false);
-    assertParse("objectPublicKey", "foo\\ bar", "foo bar", "jse", false);
-  });
-
-  test("optionalChaining", () => {
-    assertParse("optionalChaining", "?.key", [
-      ops.optionalTraverse,
-      [ops.literal, "key"],
-    ]);
+    assertParse("objectPublicKey", "a", "a", false);
+    assertParse("objectPublicKey", "markdown/", "markdown/", false);
+    assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
   });
 
   test("parenthesesArguments", () => {
@@ -994,15 +911,6 @@ Body`,
       [ops.literal, 1],
       [ops.literal, 2],
     ]);
-    // Only in JSE
-    assertParse(
-      "primary",
-      "<index.html>",
-      [ops.scope, "index.html"],
-      "jse",
-      false
-    );
-    assertThrows("primary", "<index.html>", `but "<" found`, 0, "shell");
   });
 
   test("program", () => {
@@ -1012,7 +920,6 @@ Body`,
 'Hello'
 `,
       [ops.literal, "Hello"],
-      "jse",
       false
     );
   });
@@ -1057,10 +964,6 @@ Body`,
     ]);
   });
 
-  test("regexLiteral", () => {
-    assertParse("regexLiteral", "/abc+/g", [ops.literal, /abc+/g]);
-  });
-
   test("relationalExpression", () => {
     assertParse("relationalExpression", "1 < 2", [
       ops.lessThan,
@@ -1122,7 +1025,7 @@ Body`,
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [ops.templateTree, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
+      [ops.template, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
@@ -1135,7 +1038,7 @@ Body`,
   });
 
   test("singleLineComment", () => {
-    assertParse("singleLineComment", "// Hello, world!", null, "jse", false);
+    assertParse("singleLineComment", "// Hello, world!", null, false);
   });
 
   test("spreadElement", () => {
@@ -1239,27 +1142,21 @@ Body text`,
 
   test("templateLiteral", () => {
     assertParse("templateLiteral", "`Hello, world.`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["Hello, world."]],
     ]);
-    assertParse(
-      "templateLiteral",
-      "`Hello, world.`",
-      [ops.templateStandard, [ops.literal, ["Hello, world."]]],
-      "jse"
-    );
     assertParse("templateLiteral", "`foo ${x} bar`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["foo ", " bar"]],
       [ops.scope, "x"],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["", ""]],
-      [ops.templateTree, [ops.literal, ["nested"]]],
+      [ops.template, [ops.literal, ["nested"]]],
     ]);
     assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["", ""]],
       [
         [ops.builtin, "map:"],
@@ -1267,20 +1164,14 @@ Body text`,
         [
           ops.lambda,
           [[ops.literal, "_"]],
-          [ops.templateTree, [ops.literal, ["", ""]], [ops.scope, "name"]],
+          [ops.template, [ops.literal, ["", ""]], [ops.scope, "name"]],
         ],
       ],
     ]);
   });
 
   test("templateSubtitution", () => {
-    assertParse(
-      "templateSubstitution",
-      "${foo}",
-      [ops.scope, "foo"],
-      "shell",
-      false
-    );
+    assertParse("templateSubstitution", "${foo}", [ops.scope, "foo"], false);
   });
 
   test("whitespace block", () => {
@@ -1291,7 +1182,6 @@ Body text`,
   // Second comment
      `,
       null,
-      "jse",
       false
     );
   });
@@ -1307,16 +1197,9 @@ Body text`,
   });
 });
 
-function assertParse(
-  startRule,
-  source,
-  expected,
-  mode = "shell",
-  checkLocation = true
-) {
+function assertParse(startRule, source, expected, checkLocation = true) {
   const code = parse(source, {
     grammarSource: { text: source },
-    mode,
     startRule,
   });
 
@@ -1344,11 +1227,10 @@ function assertCodeLocations(code) {
   }
 }
 
-function assertThrows(startRule, source, message, position, mode = "shell") {
+function assertThrows(startRule, source, message, position) {
   try {
     parse(source, {
       grammarSource: { text: source },
-      mode,
       startRule,
     });
   } catch (/** @type {any} */ error) {

package/test/runtime/ops.test.js

@@ -80,11 +80,7 @@ describe("ops", () => {
     assert.strictEqual(await ops.conditional(false, errorFn, trueFn), true);
   });
 
-  test("ops.construct", async () => {
-    assert.equal(await ops.construct(String, "hello"), "hello");
-  });
-
-  test("ops.document", async () => {
+  test("ops.documentFunction", async () => {
     const code = createCode([
       ops.document,
       {
@@ -94,7 +90,7 @@ describe("ops", () => {
         ops.lambda,
         [["_"]],
         [
-          ops.templateIndent,
+          ops.template,
           [ops.literal, ["a = ", ""]],
           [ops.concat, [ops.scope, "a"]],
         ],
@@ -297,11 +293,6 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.optionalTraverse", async () => {
-    assert.equal(await ops.optionalTraverse(null, "a"), undefined);
-    assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
-  });
-
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 1));
     assert(ops.notEqual(1, 2));

package/test/runtime/taggedTemplateIndent.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import indent from "../../src/runtime/templateIndent.js";
+import indent from "../../src/runtime/taggedTemplateIndent.js";
 
 describe("taggedTemplateIndent", () => {
   test("joins strings and values together if template isn't a block template", async () => {

package/src/runtime/templateStandard.js

@@ -1,13 +0,0 @@
-/**
- * Concatenate the strings with a standard tagged template function that works
- * just like normal JavaScript templates. This is: a) synchronous, b) does not
- * convert treelike objects to strings.
- */
-export default function standardTemplate(strings, ...values) {
-  let result = strings[0];
-  for (let i = 0; i < values.length; i++) {
-    result += values[i];
-    result += strings[i + 1];
-  }
-  return result;
-}

package/test/runtime/templateText.test.js

@@ -1,18 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import templateText from "../../src/runtime/templateStandard.js";
-
-describe("templateText", () => {
-  test("joins strings and values together like JavaScript", async () => {
-    const a = 1;
-    const b = 2;
-    const result = await templateText`-${a} ${b}-`;
-    assert.equal(result, "-1 2-");
-  });
-
-  test("renders an object like JavaScript", async () => {
-    const object = { a: 1 };
-    const result = await templateText`-${object}-`;
-    assert.equal(result, "-[object Object]-");
-  });
-});