@weborigami/language 0.3.1 → 0.3.3-jse.1

package/main.js

@@ -14,6 +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 taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.js";
+export { default as taggedTemplateIndent } from "./src/runtime/templateIndent.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.3.1",
+  "version": "0.3.3-jse.1",
   "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.3.1",
-    "@weborigami/types": "0.3.1",
+    "@weborigami/async-tree": "0.3.3-jse.1",
+    "@weborigami/types": "0.3.3-jse.1",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/compile.js

@@ -4,12 +4,14 @@ import { parse } from "./parse.js";
 
 function compile(source, options) {
   const { macros, startRule } = options;
+  const mode = options.mode ?? "shell";
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
   const code = parse(source.text, {
     grammarSource: source,
+    mode,
     startRule,
   });
   const optimized = optimize(code, enableCaching, macros);

package/src/compiler/origami.pegjs

@@ -40,7 +40,7 @@ __
   }
 
 additiveExpression
-  = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
+  = head:multiplicativeExpression tail:(whitespaceShell @additiveOperator whitespaceShell @multiplicativeExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -48,11 +48,49 @@ additiveOperator
   = "+"
   / "-"
 
+angleBracketLiteral
+  = "<" __ protocol:angleBracketProtocol "//" path:angleBracketPath __ ">" {
+    return annotate([protocol, ...path], location());
+    }
+  / "<" protocol:angleBracketProtocol path:angleBracketPath ">" {
+      const [head, ...tail] = path;
+      const root = annotate([protocol, head], location());
+      return annotate([ops.traverse, root, ...tail], location());
+    }
+  / "<" __ path:angleBracketPath __ ">" {
+    const [head, ...tail] = path;
+    const root = annotate([ops.scope, head[1]], location());
+    return tail.length === 0
+      ? root
+      : annotate([ops.traverse, root, ...tail], location())
+  }
+
+angleBracketPath
+  = @angleBracketPathKey|0.., "/"| "/"?
+
+angleBracketPathKey
+  = chars:angleBracketPathChar+ slashFollows:slashFollows? {
+    // Append a trailing slash if one follows (but don't consume it)
+    const key = chars.join("") + (slashFollows ? "/" : "");
+    return annotate([ops.literal, key], location());
+  }
+
+// A single character in a slash-separated path segment
+angleBracketPathChar
+  = [^/:<>] // Much more permissive than an identifier
+  / escapedChar
+
+angleBracketProtocol
+  = protocol:jsIdentifier ":" {
+      return annotate([ops.builtin, `${protocol}:`], location());
+    }
+
 arguments "function arguments"
   = parenthesesArguments
-  / pathArguments
+  / shellMode @pathArguments
   / jsPropertyAccess
   / computedPropertyAccess
+  / optionalChaining
   / templateLiteral
 
 arrayLiteral "array"
@@ -330,17 +368,10 @@ implicitParenthesesCallExpression "function call with implicit parentheses"
 // A separated list of values for an implicit parens call. This differs from
 // `list` in that the value term can't be a pipeline.
 implicitParensthesesArguments
-  = values:shorthandFunction|1.., separator| separator? {
+  = shellMode values:shorthandFunction|1.., separator| separator? {
       return annotate(values, location());
     }
 
-inherited
-  = rootDirectory
-  / homeDirectory
-  / qualifiedReference
-  / namespace
-  / scopeReference
-
 inlineSpace
   = [ \t]
 
@@ -349,6 +380,9 @@ integerLiteral "integer"
       return annotate([ops.literal, parseInt(text())], location());
     }
 
+jseMode
+  = &{ return options.mode === "jse" }
+
 jsIdentifier
   = $( jsIdentifierStart jsIdentifierPart* )
 
@@ -368,16 +402,17 @@ jsPropertyAccess
     return annotate([ops.traverse, literal], location());
   }
 
+jsReference "identifier reference"
+  = id:jsIdentifier {
+      return annotate([ops.scope, id], location());
+    }
+
 // A separated list of values
 list "list"
   = values:pipelineExpression|1.., separator| separator? {
       return annotate(values, location());
     }
 
-literal
-  = numericLiteral
-  / stringLiteral
-
 logicalAndExpression
   = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
@@ -402,7 +437,7 @@ multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
 multiplicativeExpression
-  = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
+  = head:exponentiationExpression tail:(whitespaceShell @multiplicativeOperator whitespaceShell @exponentiationExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -417,6 +452,13 @@ namespace
     return annotate([ops.builtin, chars.join("") + ":"], location());
   }
 
+// A new expression: `new Foo()`
+newExpression
+  = "new" __ head:jsReference tail:parenthesesArguments {
+      const args = tail?.[0] !== undefined ? tail : [];
+      return annotate([ops.construct, head, ...args], location());
+    }
+
 newLine
   = "\n"
   / "\r\n"
@@ -486,13 +528,18 @@ objectShorthandProperty "object identifier"
 
 objectPublicKey
   = identifier:identifier slash:"/"? {
-    return identifier + (slash ?? "");
-  }
+      return identifier + (slash ?? "");
+    }
   / string:stringLiteral {
-    // Remove `ops.literal` from the string code
-    return string[1];
-  }
+      // Remove `ops.literal` from the string code
+      return string[1];
+    }
 
+optionalChaining
+  = __ "?." __ property:jsIdentifier {
+    const literal = annotate([ops.literal, property], location());
+    return annotate([ops.optionalTraverse, literal], location());
+  }
 parameter
   = identifier:identifier {
       return annotate([ops.literal, identifier], location());
@@ -562,12 +609,27 @@ pipelineExpression
     }
 
 primary
-  = literal
+  = numericLiteral
+  / stringLiteral
   / arrayLiteral
   / objectLiteral
   / group
   / templateLiteral
-  / inherited
+  / shellMode @primaryShell
+  / jseMode @primaryJse
+
+// Primary allowed in JSE mode
+primaryJse
+  = angleBracketLiteral
+  / jsReference
+  / regexLiteral
+
+primaryShell
+  = rootDirectory
+  / homeDirectory
+  / qualifiedReference
+  / namespace
+  / scopeReference
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
 program "Origami program"
@@ -579,6 +641,7 @@ protocolExpression
       const keys = annotate([host, ...(path ?? [])], location());
       return makeCall(fn, keys);
     }
+  / newExpression
   / primary
 
 // A namespace followed by a key: `foo:x`
@@ -588,6 +651,21 @@ qualifiedReference
       return makeCall(fn, [literal]);
     }
 
+regexFlags
+  = flags:[gimuy]* {
+      return flags.join("");
+    }
+
+regexLiteral
+  = "/" chars:regexLiteralChar* "/" flags:regexFlags? {
+      const regex = new RegExp(chars.join(""), flags);
+      return annotate([ops.literal, regex], location());
+    }
+
+regexLiteralChar
+  = [^/\n\r] // No unescaped slashes or newlines
+  / escapedChar
+
 relationalExpression
   = head:shiftExpression tail:(__ @relationalOperator __ @shiftExpression)* {
       return tail.reduce(makeBinaryOperation, head);
@@ -617,11 +695,14 @@ scopeReference "scope reference"
 
 separator
   = __ "," __
-  / whitespaceWithNewLine
+  / shellMode @whitespaceWithNewLine
 
 shebang
   = "#!" [^\n\r]* { return null; }
 
+shellMode
+  = &{ return options.mode === "shell" }
+
 shiftExpression
   = head:additiveExpression tail:(__ @shiftOperator __ @additiveExpression)* {
       return tail.reduce(makeBinaryOperation, head);
@@ -635,7 +716,7 @@ shiftOperator
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
-  = "=" !"=" __ definition:implicitParenthesesCallExpression {
+  = shellMode "=" !"=" __ definition:implicitParenthesesCallExpression {
       const lambdaParameters = annotate(
         [annotate([ops.literal, "_"], location())],
         location()
@@ -680,7 +761,7 @@ spreadElement
 stringLiteral "string"
   = doubleQuoteString
   / singleQuoteString
-  / guillemetString
+  / shellMode @guillemetString
 
 // The body of a template document is a kind of template literal that can
 // contain backticks at the top level.
@@ -707,7 +788,8 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
-      return annotate(applyMacro(front, "@template", body), location());
+      const macroName = options.mode === "jse" ? "_template" : "@template";
+      return annotate(applyMacro(front, macroName, body), location());
     }
   / front:frontMatterYaml? body:templateBody {
       return front
@@ -718,7 +800,8 @@ templateDocument "template document"
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
-      return makeTemplate(ops.template, head, tail, location());
+      const op = options.mode === "jse" ? ops.templateStandard : ops.templateTree;
+      return makeTemplate(op, head, tail, location());
     }
 
 templateLiteralChar
@@ -750,7 +833,9 @@ unaryExpression
 unaryOperator
   = "!"
   / "+"
-  / "-"
+  // Don't match a front matter delimiter. For some reason, the negative
+  // lookahead !"--\n" doesn't work.
+  / @"-" !"-\n"
   / "~"
 
 whitespace
@@ -758,5 +843,10 @@ whitespace
   / newLine
   / comment
 
+// Whitespace requires in shell mode, optional in JSE mode
+whitespaceShell
+  = shellMode whitespace
+  / jseMode __
+
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __