@weborigami/language 0.3.4-jse.6 → 0.3.4-jse.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.3.4-jse.6",
+  "version": "0.3.4-jse.8",
   "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.4-jse.6",
-    "@weborigami/types": "0.3.4-jse.6",
+    "@weborigami/async-tree": "0.3.4-jse.8",
+    "@weborigami/types": "0.3.4-jse.8",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/optimize.js

@@ -37,8 +37,8 @@ export default function optimize(code, options = {}) {
   const [op, ...args] = code;
   switch (op) {
     case markers.global:
-      // Replace global op with the globals
-      return annotate([globals, args[0]], code.location);
+      // Replace with the indicated global
+      return globals[args[0]];
 
     case markers.traverse:
       return resolvePath(code, globals, locals, cache);
@@ -140,7 +140,7 @@ function compoundReference(key, globals, locals, location) {
   const type = referenceType(head, globals, locals);
   let result;
   if (type === REFERENCE_GLOBAL) {
-    result = globalReference(head, globals, location);
+    result = globalReference(head, globals);
   } else if (type === REFERENCE_LOCAL) {
     result = localReference(head, locals, location);
   } else {
@@ -177,9 +177,9 @@ function getLocalReferenceDepth(locals, key) {
   return depth;
 }
 
-function globalReference(key, globals, location) {
+function globalReference(key, globals) {
   const normalized = trailingSlash.remove(key);
-  return annotate([globals, normalized], location);
+  return globals[normalized];
 }
 
 function inlineLiteral(code) {
@@ -249,24 +249,29 @@ function reference(code, globals, locals) {
 
   // See if the whole key is a global or local variable
   let type = referenceType(key, globals, locals);
-  let result;
   if (type === REFERENCE_GLOBAL) {
-    result = globalReference(key, globals, location);
+    return {
+      type,
+      result: globalReference(key, globals),
+    };
   } else if (type === REFERENCE_LOCAL) {
-    result = localReference(key, locals, location);
-  } else {
-    // Try key as a compound reference x.y.z
-    const compound = compoundReference(key, globals, locals, location);
-    result = compound?.result;
-    type = compound?.type;
+    return {
+      type,
+      result: localReference(key, locals, location),
+    };
   }
 
-  if (!result) {
-    // If none of the above worked, it must be an external reference
-    result = externalReference(key, locals, location);
+  // Try key as a compound reference x.y.z
+  const compound = compoundReference(key, globals, locals, location);
+  if (compound.type !== REFERENCE_EXTERNAL) {
+    return compound;
   }
 
-  return { type, result };
+  // Not a compound reference, must be external
+  return {
+    type: REFERENCE_EXTERNAL,
+    result: externalReference(key, locals, location),
+  };
 }
 
 function referenceType(key, globals, locals) {
@@ -287,7 +292,13 @@ function resolvePath(code, globals, locals, cache) {
 
   let { type, result } = reference(head, globals, locals);
 
-  result.push(...tail);
+  if (tail.length > 0) {
+    if (result instanceof Array) {
+      result.push(...tail);
+    } else {
+      result = annotate([result, ...tail], code.location);
+    }
+  }
 
   if (type === REFERENCE_EXTERNAL && cache !== null) {
     // Cache external path

package/src/compiler/origami.pegjs

@@ -164,10 +164,17 @@ comment "comment"
   / singleLineComment
 
 computedPropertyAccess
-  = __ "[" expression:expression expectClosingBracket {
+  = computedPropertySpace "[" expression:expectExpression expectClosingBracket {
       return annotate([markers.property, expression], location());
     }
 
+// A space before a computed property access. This is allowed when in not in
+// shell mode, but not in shell mode. In shell mode `foo [bar]` should parse as
+// a function call with a single argument of an array, not as a property access.
+computedPropertySpace
+  = shellMode
+  / !shellMode __
+
 conditionalExpression
   = condition:logicalOrExpression tail:(__
     "?" __ @shorthandFunction __
@@ -254,7 +261,7 @@ expectDoubleQuote
 expectExpression
   = expression
   / .? {
-      error("Expected an Origami expression");
+      error("Expected an expression");
     }
 
 expectFrontDelimiter
@@ -282,6 +289,12 @@ expectPipelineExpression
       error("Expected an expression");
     }
 
+expectUnaryExpression
+  = unaryExpression
+  / .? {
+      error("Expected an expression");
+    }
+
 exponentiationExpression
   = left:unaryExpression right:(whitespace "**" whitespace @exponentiationExpression)? {
       return right ? annotate([ops.exponentiation, left, right], location()) : left;
@@ -319,7 +332,7 @@ frontMatterYaml "YAML front matter"
 
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" expression:expression expectClosingParenthesis {
+  = "(" expression:expectExpression expectClosingParenthesis {
     return annotate(expression, location());
   }
 
@@ -767,7 +780,12 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
+      // TODO: Deprecate @template
       const macroName = text().includes("@template") ? "@template" : "_template";
+      if (macroName === "@template") {
+        // If the front matter is a macro, apply it to the body
+        console.warn("Warning: the @template() macro is deprecated. Use _template() instead.");
+      }
       return annotate(applyMacro(front, macroName, body), location());
     }
   / front:frontMatterYaml body:templateBody {
@@ -811,7 +829,7 @@ textChar
 
 // A unary prefix operator: `!x`
 unaryExpression
-  = operator:unaryOperator __ expression:expectExpression {
+  = operator:unaryOperator __ expression:expectUnaryExpression {
       return makeUnaryOperation(operator, expression, location());
     }
   / callExpression
@@ -848,7 +866,8 @@ uriKey
 // A single character in a URI key
 uriKeyChar
   // Accept anything that doesn't end the URI key or path
-  = [^/,\)\]\}\s]
+  // Note: Peggy doesn't support `/s` so we list space and tab explicitly.
+  = [^/,\)\]\} \t]
   / escapedChar
 
 // A slash-separated path of keys: `a/b/c`
@@ -871,8 +890,9 @@ unaryOperator
   / minus
 
 whitespace
-  = inlineSpace
-  / newLine
+  // JavaScript considers a large number of characters whitespace so we use the
+  // `/s` definition to avoid missing any.
+  = char:. &{ return /\s/.test(char); } { return char; }
   / comment
 
 whitespaceWithNewLine