@weborigami/language 0.0.68 → 0.0.70

package/main.js

@@ -11,5 +11,7 @@ export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtens
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
 export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.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 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.0.68",
+  "version": "0.0.70",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.68",
-    "@weborigami/types": "0.0.68",
+    "@weborigami/async-tree": "0.0.70",
+    "@weborigami/types": "0.0.70",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -5,10 +5,7 @@ function compile(source, startRule) {
   if (typeof source === "string") {
     source = { text: source };
   }
-  // Trim whitespace from template blocks before we begin lexing, as our
-  // heuristics are non-local and hard to implement in our parser.
-  const preprocessed = trimTemplateWhitespace(source.text);
-  const parseResult = parse(preprocessed, {
+  const parseResult = parse(source.text, {
     grammarSource: source,
     startRule,
   });
@@ -23,39 +20,3 @@ export function expression(source) {
 export function templateDocument(source) {
   return compile(source, "templateDocument");
 }
-
-// Trim the whitespace around and in substitution blocks in a template. There's
-// no explicit syntax for blocks, but we infer them as any place where a
-// substitution itself contains a multi-line template literal.
-//
-// Example:
-//
-//     ${ if `
-//       true text
-//     `, `
-//       false text
-//     ` }
-//
-// Case 1: a substitution that starts the text or starts a line (there's only
-// whitespace before the `${`), and has the line end with the start of a
-// template literal (there's only whitespace after the backtick) marks the start
-// of a block.
-//
-// Case 2: a line in the middle that ends one template literal and starts
-// another is an internal break in the block. Edge case: three backticks in a
-// row, like ```, are common in markdown and are not treated as a break.
-//
-// Case 3: a line that ends a template literal and ends with `}` or ends the
-// text marks the end of the block.
-//
-// In all three cases, we trim spaces and tabs from the start and end of the
-// line. In case 1, we also remove the preceding newline.
-function trimTemplateWhitespace(text) {
-  const regex1 = /(^|\n)[ \t]*((?:{{|\${).*?`)[ \t]*\n/g;
-  const regex2 = /\n[ \t]*(`(?!`).*?`)[ \t]*\n/g;
-  const regex3js = /\n[ \t]*(`(?!`).*?(?:}}|[^\\]}))[ \t]*(?:\n|$)/g;
-  const trimBlockStarts = text.replace(regex1, "$1$2");
-  const trimBlockBreaks = trimBlockStarts.replace(regex2, "\n$1");
-  const trimBlockEnds = trimBlockBreaks.replace(regex3js, "\n$1");
-  return trimBlockEnds;
-}

package/src/compiler/origami.pegjs

@@ -13,6 +13,7 @@ import {
   makeFunctionCall,
   makeObject,
   makePipeline,
+  makeProperty,
   makeTemplate
 } from "./parserHelpers.js";
 
@@ -102,7 +103,7 @@ doubleArrow = "⇒" / "=>"
 
 doubleQuoteString "double quote string"
   = '"' chars:doubleQuoteStringChar* '"' {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 doubleQuoteStringChar
@@ -131,13 +132,21 @@ expression "Origami expression"
 
 float "floating-point number"
   = sign? digits? "." digits {
-      return annotate([ops.primitive, parseFloat(text())], location());
+      return annotate([ops.literal, parseFloat(text())], location());
     }
 
 // Parse a function and its arguments, e.g. `fn(arg)`, possibly part of a chain
 // of function calls, like `fn(arg1)(arg2)(arg3)`.
 functionComposition "function composition"
-  = target:callTarget chain:args* end:implicitParensArgs? {
+  // Function with at least one argument and maybe implicit parens arguments
+  = target:callTarget chain:args+ end:implicitParensArgs? {
+      if (end) {
+        chain.push(end);
+      }
+      return annotate(makeFunctionCall(target, chain, location()), location());
+    }
+  // Function with implicit parens arguments after maybe other arguments
+  / target:callTarget chain:args* end:implicitParensArgs {
       if (end) {
         chain.push(end);
       }
@@ -152,7 +161,7 @@ group "parenthetical group"
 
 guillemetString "guillemet string"
   = '«' chars:guillemetStringChar* '»' {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 guillemetStringChar
@@ -165,7 +174,7 @@ host "HTTP/HTTPS host"
   = identifier:identifier port:(":" @number)? {
     const portText = port ? `:${port[1]}` : "";
     const hostText = identifier + portText;
-    return annotate([ops.primitive, hostText], location());
+    return annotate([ops.literal, hostText], location());
   }
 
 identifier "identifier"
@@ -194,7 +203,7 @@ inlineSpace
 
 integer "integer"
   = sign? digits {
-      return annotate([ops.primitive, parseInt(text())], location());
+      return annotate([ops.literal, parseInt(text())], location());
     }
 
 // A lambda expression: `=foo()`
@@ -249,7 +258,7 @@ objectEntry
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
   = key:objectKey __ "=" __ value:expr {
-      return annotate([key, [ops.getter, value]], location());
+      return annotate(makeProperty(key, [ops.getter, value]), location());
     }
 
 objectHiddenKey
@@ -262,7 +271,7 @@ objectKey "object key"
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
   = key:objectKey __ ":" __ value:expr {
-      return annotate([key, value], location());  
+      return annotate(makeProperty(key, value), location());
     }
 
 // A shorthand reference inside an object literal: `foo`
@@ -276,7 +285,7 @@ objectPublicKey
     return identifier + (slash ?? "");
   }
   / string:string {
-    // Remove `ops.primitive` from the string code
+    // Remove `ops.literal` from the string code
     return string[1];
   }
 
@@ -308,7 +317,7 @@ path "slash-separated path"
 // A path key followed by a slash
 pathElement
   = chars:pathKeyChar* "/" {
-    return annotate([ops.primitive, chars.join("") + "/"], location());
+    return annotate([ops.literal, chars.join("") + "/"], location());
   }
 
 // A single character in a slash-separated path.
@@ -321,7 +330,7 @@ pathKeyChar
 // A path key without a slash
 pathTail
   = chars:pathKeyChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 // Parse a protocol call like `fn://foo/bar`.
@@ -353,6 +362,7 @@ scopeReference "scope reference"
 scopeTraverse
   = ref:scopeReference "/" path:path {
       const head = [ops.scope, `${ ref[1] }/`];
+      head.location = ref.location;
       return annotate([ops.traverse, head, ...path], location());
     }
 
@@ -373,7 +383,7 @@ singleLineComment
 
 singleQuoteString "single quote string"
   = "'" chars:singleQuoteStringChar* "'" {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 singleQuoteStringChar
@@ -401,8 +411,10 @@ step
   / templateLiteral
   / string
   / group
-  // Protocol calls are distinguished by a colon, but it's not at the start.
+  // Things that have a distinctive character, but not at the start
   / protocolCall
+  / taggedTemplate
+  / scopeTraverse
   // Least distinctive option is a simple scope reference, so it comes last.
   / scopeReference
 
@@ -414,6 +426,11 @@ string "string"
   / singleQuoteString
   / guillemetString
 
+taggedTemplate
+  = tag:callTarget "`" contents:templateLiteralContents "`" {
+      return annotate(makeTemplate(tag, contents[0], contents[1]), location());
+    }
+
 // A top-level document defining a template. This is the same as a template
 // literal, but can contain backticks at the top level.
 templateDocument "template"
@@ -427,19 +444,19 @@ templateDocumentChar
 
 // The contents of a template document containing plain text and substitutions
 templateDocumentContents
-  = parts:(templateDocumentText / templateSubstitution)* {
-      return annotate(makeTemplate(parts), location());
+  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
+      return annotate(makeTemplate(ops.template, head, tail), location());
     }
 
 templateDocumentText "template text"
-  = chars:templateDocumentChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
-  }
+  = chars:templateDocumentChar* {
+      return chars.join("");
+    }
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" contents:templateLiteralContents "`" {
-      return annotate(contents, location());
+      return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
     }
 
 templateLiteralChar
@@ -447,21 +464,17 @@ templateLiteralChar
 
 // The contents of a template literal containing plain text and substitutions
 templateLiteralContents
-  = parts:(templateLiteralText / templateSubstitution)* {
-      return annotate(makeTemplate(parts), location());
-    }
+  = head:templateLiteralText tail:(templateSubstitution templateLiteralText)*
 
 // Plain text in a template literal
 templateLiteralText
-  = chars:templateLiteralChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
-  }
+  = chars:templateLiteralChar* {
+      return chars.join("");
+    }
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" __ expr:expr __ "}" {
-      return annotate(expr, location());
-    }
+  = "${" __ @expr __ "}"
 
 textChar
   = escapedChar