@weborigami/language 0.3.1 → 0.3.3-jse.1

package/src/compiler/parserHelpers.js

@@ -204,7 +204,8 @@ export function makeCall(target, args) {
   }
 
   let fnCall;
-  if (args[0] === ops.traverse) {
+  const op = args[0];
+  if (op === ops.traverse || op === ops.optionalTraverse) {
     let tree = target;
 
     if (tree[0] === undetermined) {
@@ -219,12 +220,12 @@ export function makeCall(target, args) {
     if (args.length > 1) {
       // Regular traverse
       const keys = args.slice(1);
-      fnCall = [ops.traverse, tree, ...keys];
+      fnCall = [op, tree, ...keys];
     } else {
       // Traverse without arguments equates to unpack
       fnCall = [ops.unpack, tree];
     }
-  } else if (args[0] === ops.template) {
+  } else if (op === ops.templateStandard || op === ops.templateTree) {
     // Tagged template
     const strings = args[1];
     const values = args.slice(2);
@@ -275,6 +276,15 @@ 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.
  *
@@ -364,15 +374,6 @@ 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/expressionObject.js

@@ -1,6 +1,7 @@
 import {
   extension,
   ObjectTree,
+  setParent,
   symbols,
   trailingSlash,
   Tree,
@@ -116,12 +117,7 @@ export default async function expressionObject(entries, parent) {
   });
 
   // Attach the parent
-  Object.defineProperty(object, symbols.parent, {
-    configurable: true,
-    enumerable: false,
-    value: parent,
-    writable: true,
-  });
+  setParent(object, parent);
 
   // Evaluate any properties that were declared as immediate: get their value
   // and overwrite the property getter with the actual value.

package/src/runtime/handlers.js

@@ -5,7 +5,7 @@ import {
   isStringLike,
   isUnpackable,
   scope,
-  symbols,
+  setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
 
@@ -74,9 +74,12 @@ export async function handleExtension(parent, value, key) {
       key = trailingSlash.remove(key);
     }
 
-    // Special case: `.ori.<ext>` extensions are Origami documents.
+    // Special cases: `.ori.<ext>` extensions are Origami documents,
+    // `.jse.<ext>` are JSE documents.
     const extname = key.match(/\.ori\.\S+$/)
       ? ".oridocument"
+      : key.match(/\.jse\.\S+$/)
+      ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
       const handler = await getExtensionHandler(parent, extname);
@@ -92,7 +95,7 @@ export async function handleExtension(parent, value, key) {
         if (handler.mediaType) {
           value.mediaType = handler.mediaType;
         }
-        value[symbols.parent] = parent;
+        setParent(value, parent);
 
         const unpack = handler.unpack;
         if (unpack) {

package/src/runtime/ops.js

@@ -11,17 +11,18 @@ import {
   deepText,
   isUnpackable,
   scope as scopeFn,
-  symbols,
-  concat as treeConcat,
+  setParent,
+  text as templateFunctionTree,
 } 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", {
@@ -105,7 +106,7 @@ addOpLabel(comma, "«ops.comma»");
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return treeConcat.call(this, args);
+  return deepText.call(this, args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -114,6 +115,13 @@ 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.
@@ -131,7 +139,7 @@ export async function document(frontData, bodyCode) {
     ...frontData,
     "@text": body,
   };
-  object[symbols.parent] = this;
+  setParent(object, this);
   return object;
 }
 addOpLabel(document, "«ops.document");
@@ -224,7 +232,8 @@ export async function inherited(key) {
     return undefined;
   }
   const parentScope = scopeFn(this.parent);
-  return parentScope.get(key);
+  const value = await parentScope.get(key);
+  return value;
 }
 addOpLabel(inherited, "«ops.inherited»");
 
@@ -388,17 +397,33 @@ export async function merge(...codes) {
     return directObject;
   }
 
-  // Second pass: evaluate the trees with the direct properties object in scope
-  let context;
-  if (directObject) {
-    context = Tree.from(directObject);
-    context.parent = this;
-  } else {
-    context = this;
-  }
-
+  // If we have direct property entries, create a context for them. The
+  // `expressionObject` function will set the object's parent symbol to `this`.
+  // Tree.from will call the ObjectTree constructor, which will use that symbol
+  // to set the parent for the new tree to `this`.
+  const context = directObject ? Tree.from(directObject) : this;
+
+  // Second pass: evaluate the trees. For the trees which are direct property
+  // entries, we'll copy over the values we've already calculated. We can't
+  // reuse the `directObject` as is because in a merge we need to respect the
+  // order in which the properties are defined. Trees that aren't direct
+  // property entries are evaluated with the direct property entries in scope.
   const trees = await Promise.all(
-    codes.map(async (code) => evaluate.call(context, code))
+    codes.map(async (code) => {
+      if (code[0] === object) {
+        // Using the code as reference, create a new object with the direct
+        // property values we've already calculated.
+        const object = {};
+        for (const [key] of code.slice(1)) {
+          // @ts-ignore directObject will always be defined
+          object[key] = directObject[key];
+        }
+        setParent(object, this);
+        return object;
+      } else {
+        return evaluate.call(context, code);
+      }
+    })
   );
 
   return mergeTrees.call(this, ...trees);
@@ -455,6 +480,14 @@ 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;
 }
@@ -529,21 +562,29 @@ 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 async function template(strings, ...values) {
-  return deepText(strings, ...values);
+export function templateStandard(strings, ...values) {
+  return templateFunctionStandard(strings, ...values);
 }
-addOpLabel(template, "«ops.template»");
+addOpLabel(templateStandard, "«ops.templateStandard»");
 
 /**
- * Apply the tagged template indent function.
+ * Apply the tree tagged template function.
  */
-export async function templateIndent(strings, ...values) {
-  return taggedTemplateIndent(strings, ...values);
+export async function templateTree(strings, ...values) {
+  return templateFunctionTree(strings, ...values);
 }
-addOpLabel(templateIndent, "«ops.templateIndent");
+addOpLabel(templateTree, "«ops.templateTree»");
 
 /**
  * Traverse a path of keys through a tree.

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

@@ -1,4 +1,4 @@
-import { concat, toString, Tree } from "@weborigami/async-tree";
+import { text, 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) ? concat(value) : value))
+    values.map((value) => (Tree.isTreelike(value) ? text(value) : value))
   );
   return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }

package/src/runtime/templateStandard.js

@@ -0,0 +1,13 @@
+/**
+ * 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/compiler/parse.test.js

@@ -19,6 +19,46 @@ 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]", [
@@ -399,7 +439,8 @@ Body`,
     ]);
 
     // Consecutive slashes at start of something = comment
-    assertParse("expression", "path //comment", [ops.scope, "path"], false);
+    assertParse("expression", "x //comment", [ops.scope, "x"], "jse", false);
+
     assertParse("expression", "page.ori(mdHtml:(about.md))", [
       [ops.scope, "page.ori"],
       [
@@ -446,7 +487,11 @@ Body`,
     ]);
     assertParse("expression", "fn =`x`", [
       [ops.builtin, "fn"],
-      [ops.lambda, [[ops.literal, "_"]], [ops.template, [ops.literal, ["x"]]]],
+      [
+        ops.lambda,
+        [[ops.literal, "_"]],
+        [ops.templateTree, [ops.literal, ["x"]]],
+      ],
     ]);
     assertParse("expression", "copy app.js(formulas), files:snapshot", [
       [ops.builtin, "copy"],
@@ -464,7 +509,7 @@ Body`,
       [
         ops.lambda,
         [[ops.literal, "_"]],
-        [ops.template, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
+        [ops.templateTree, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
       ],
     ]);
     assertParse("expression", `https://example.com/about/`, [
@@ -523,6 +568,23 @@ 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"]);
@@ -544,10 +606,10 @@ Body`,
   });
 
   test("identifier", () => {
-    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);
+    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);
   });
 
   test("implicitParenthesesCallExpression", () => {
@@ -586,8 +648,8 @@ Body`,
   });
 
   test("jsIdentifier", () => {
-    assertParse("jsIdentifier", "foo", "foo", false);
-    assertParse("jsIdentifier", "$Δelta", "$Δelta", false);
+    assertParse("jsIdentifier", "foo", "foo", "jse", false);
+    assertParse("jsIdentifier", "$Δelta", "$Δelta", "jse", false);
     assertThrows(
       "jsIdentifier",
       "1stCharacterIsNumber",
@@ -627,6 +689,7 @@ 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"],
@@ -662,7 +725,13 @@ Body`,
   });
 
   test("multiLineComment", () => {
-    assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
+    assertParse(
+      "multiLineComment",
+      "/*\nHello, world!\n*/",
+      null,
+      "jse",
+      false
+    );
   });
 
   test("multiplicativeExpression", () => {
@@ -687,6 +756,13 @@ 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,
@@ -839,9 +915,16 @@ Body`,
   });
 
   test("objectPublicKey", () => {
-    assertParse("objectPublicKey", "a", "a", false);
-    assertParse("objectPublicKey", "markdown/", "markdown/", false);
-    assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
+    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"],
+    ]);
   });
 
   test("parenthesesArguments", () => {
@@ -911,6 +994,15 @@ 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", () => {
@@ -920,6 +1012,7 @@ Body`,
 'Hello'
 `,
       [ops.literal, "Hello"],
+      "jse",
       false
     );
   });
@@ -964,6 +1057,10 @@ Body`,
     ]);
   });
 
+  test("regexLiteral", () => {
+    assertParse("regexLiteral", "/abc+/g", [ops.literal, /abc+/g]);
+  });
+
   test("relationalExpression", () => {
     assertParse("relationalExpression", "1 < 2", [
       ops.lessThan,
@@ -1025,7 +1122,7 @@ Body`,
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [ops.template, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
+      [ops.templateTree, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
@@ -1038,7 +1135,7 @@ Body`,
   });
 
   test("singleLineComment", () => {
-    assertParse("singleLineComment", "// Hello, world!", null, false);
+    assertParse("singleLineComment", "// Hello, world!", null, "jse", false);
   });
 
   test("spreadElement", () => {
@@ -1142,21 +1239,27 @@ Body text`,
 
   test("templateLiteral", () => {
     assertParse("templateLiteral", "`Hello, world.`", [
-      ops.template,
+      ops.templateTree,
       [ops.literal, ["Hello, world."]],
     ]);
+    assertParse(
+      "templateLiteral",
+      "`Hello, world.`",
+      [ops.templateStandard, [ops.literal, ["Hello, world."]]],
+      "jse"
+    );
     assertParse("templateLiteral", "`foo ${x} bar`", [
-      ops.template,
+      ops.templateTree,
       [ops.literal, ["foo ", " bar"]],
       [ops.scope, "x"],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
-      ops.template,
+      ops.templateTree,
       [ops.literal, ["", ""]],
-      [ops.template, [ops.literal, ["nested"]]],
+      [ops.templateTree, [ops.literal, ["nested"]]],
     ]);
     assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
-      ops.template,
+      ops.templateTree,
       [ops.literal, ["", ""]],
       [
         [ops.builtin, "map:"],
@@ -1164,14 +1267,20 @@ Body text`,
         [
           ops.lambda,
           [[ops.literal, "_"]],
-          [ops.template, [ops.literal, ["", ""]], [ops.scope, "name"]],
+          [ops.templateTree, [ops.literal, ["", ""]], [ops.scope, "name"]],
         ],
       ],
     ]);
   });
 
   test("templateSubtitution", () => {
-    assertParse("templateSubstitution", "${foo}", [ops.scope, "foo"], false);
+    assertParse(
+      "templateSubstitution",
+      "${foo}",
+      [ops.scope, "foo"],
+      "shell",
+      false
+    );
   });
 
   test("whitespace block", () => {
@@ -1182,6 +1291,7 @@ Body text`,
   // Second comment
      `,
       null,
+      "jse",
       false
     );
   });
@@ -1197,9 +1307,16 @@ Body text`,
   });
 });
 
-function assertParse(startRule, source, expected, checkLocation = true) {
+function assertParse(
+  startRule,
+  source,
+  expected,
+  mode = "shell",
+  checkLocation = true
+) {
   const code = parse(source, {
     grammarSource: { text: source },
+    mode,
     startRule,
   });
 
@@ -1227,10 +1344,11 @@ function assertCodeLocations(code) {
   }
 }
 
-function assertThrows(startRule, source, message, position) {
+function assertThrows(startRule, source, message, position, mode = "shell") {
   try {
     parse(source, {
       grammarSource: { text: source },
+      mode,
       startRule,
     });
   } catch (/** @type {any} */ error) {

package/test/runtime/ops.test.js

@@ -80,7 +80,11 @@ describe("ops", () => {
     assert.strictEqual(await ops.conditional(false, errorFn, trueFn), true);
   });
 
-  test("ops.documentFunction", async () => {
+  test("ops.construct", async () => {
+    assert.equal(await ops.construct(String, "hello"), "hello");
+  });
+
+  test("ops.document", async () => {
     const code = createCode([
       ops.document,
       {
@@ -90,7 +94,7 @@ describe("ops", () => {
         ops.lambda,
         [["_"]],
         [
-          ops.template,
+          ops.templateIndent,
           [ops.literal, ["a = ", ""]],
           [ops.concat, [ops.scope, "a"]],
         ],
@@ -293,6 +297,11 @@ 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/taggedTemplateIndent.js";
+import indent from "../../src/runtime/templateIndent.js";
 
 describe("taggedTemplateIndent", () => {
   test("joins strings and values together if template isn't a block template", async () => {

package/test/runtime/templateText.test.js

@@ -0,0 +1,18 @@
+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]-");
+  });
+});