@weborigami/language 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.3",
+    "@weborigami/async-tree": "0.6.4",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -62,7 +62,10 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const propertyNames = entries.map((entry) => entryKey(entry));
+      // Filter out computed property keys when determining local variables
+      const propertyNames = entries
+        .map((entry) => entryKey(entry))
+        .filter((key) => key !== null);
       locals.push({
         type: REFERENCE_INHERITED,
         names: propertyNames,
@@ -79,16 +82,18 @@ export default function optimize(code, options = {}) {
       } else if (op === ops.object && index > 0) {
         const [key, value] = child;
         const adjustedLocals = avoidLocalRecursion(locals, key);
-        return annotate(
-          [
-            key,
-            optimize(/** @type {AnnotatedCode} */ (value), {
-              ...options,
-              locals: adjustedLocals,
-            }),
-          ],
-          child.location
-        );
+        const optimizedKey =
+          typeof key === "string"
+            ? key
+            : optimize(/** @type {AnnotatedCode} */ (key), {
+                ...options,
+                locals: adjustedLocals,
+              });
+        const optimizedValue = optimize(/** @type {AnnotatedCode} */ (value), {
+          ...options,
+          locals: adjustedLocals,
+        });
+        return annotate([optimizedKey, optimizedValue], child.location);
       } else if (Array.isArray(child) && "location" in child) {
         // Review: Aside from ops.object (above), what non-instruction arrays
         // does this descend into?

package/src/compiler/origami.pegjs

@@ -18,6 +18,7 @@ import {
   makeArray,
   makeBinaryOperation,
   makeCall,
+  makeCallChain,
   makeDeferredArguments,
   makeDocument,
   makeObject,
@@ -83,7 +84,7 @@ arguments "function arguments"
   / pathArguments
   / propertyAccess
   / computedPropertyAccess
-  // / optionalChaining
+  / optional
   / templateLiteral
 
 arrayLiteral "array"
@@ -143,10 +144,7 @@ bitwiseXorOperator
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
   = head:uriExpression tail:arguments* {
-      return tail.reduce(
-        (target, args) => makeCall(target, args, location()),
-        head
-      );
+      return makeCallChain(head, tail, location());
     }
 
 // A comma-separated list of expressions: `x, y, z`
@@ -168,9 +166,9 @@ computedPropertyAccess
       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.
+// A space before a computed property access. This is allowed when 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 __
@@ -383,16 +381,27 @@ identifierPart "JavaScript identifier continuation"
 identifierStart "JavaScript identifier start"
   = char:. &{ return char.match(/[$_\p{ID_Start}]/u) }
 
-implicitParenthesesCallExpression "function call with implicit parentheses"
-  = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
-      return args ? makeCall(head, args, location()) : head;
+// A single argument for an implicit parens call. This differs from
+// `parenthesesArgument` in that the term can't be a pipeline.
+implicitParenthesesArgument
+  = "..." arg:shorthandFunction {
+      return annotate([markers.spread, arg], location());
+    }
+  / shorthandFunction
+
+// A separated list of arguments for an implicit parens call.
+implicitParenthesesArgumentList "list"
+  = args:implicitParenthesesArgument|1.., separator| separator? {
+      return annotate(args, location());
     }
     
-// 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
-  = shellMode values:shorthandFunction|1.., separator| separator? {
-      return annotate(values, location());
+// A separated list of values for an implicit parens call. 
+implicitParenthesesArguments
+  = shellMode inlineSpace+ @implicitParenthesesArgumentList
+
+implicitParenthesesCallExpression "function call with implicit parentheses"
+  = head:arrowFunction args:implicitParenthesesArguments? {
+      return args ? makeCall(head, args, location()) : head;
     }
 
 inlineSpace
@@ -430,12 +439,6 @@ keyCharStart
   / "@"
   / "~"
 
-// A separated list of values
-list "list"
-  = values:pipelineExpression|1.., separator| separator? {
-      return annotate(values, location());
-    }
-
 logicalAndExpression
   = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
@@ -561,7 +564,8 @@ objectShorthandProperty "object identifier"
     }
 
 objectPublicKey
-  = key:key slash:"/"? {
+  = "[" __ @pipelineExpression __ expectClosingBracket
+  / key:key slash:"/"? {
       return text();
     }
   / string:stringLiteral {
@@ -569,12 +573,20 @@ objectPublicKey
       return string[1];
     }
 
-optionalChaining
-  = __ "?." __ property:identifier {
-      return annotate([ops.optionalTraverse, property], location());
+// Optional chaining
+optional
+  = __ "?." args:parenthesesArguments {
+      return annotate([ops.optional, args], location());
+    }
+  / __ "?." access:computedPropertyAccess {
+      return annotate([ops.optional, access], location());
+    }
+  / __ "?." whitespaceOptionalForProgram property:identifierLiteral {
+      const propertyAccess = annotate([markers.property, property], location());
+      return annotate([ops.optional, propertyAccess], location());
     }
 
-// Name of a unction parameter
+// Name of a function parameter
 parameter
   = key:key {
       return annotate([ops.literal, key], location());
@@ -591,9 +603,22 @@ parameterSingleton
       return annotate([param], location());
     }
 
+// A single argument inside parentheses
+parenthesesArgument
+  = "..." arg:pipelineExpression {
+      return annotate([markers.spread, arg], location());
+    }
+  / pipelineExpression
+
+// A separated list of arguments inside parentheses
+parenthesesArgumentList "list"
+  = args:parenthesesArgument|1.., separator| separator? {
+      return annotate(args, location());
+    }
+
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
-  = "(" __ list:list? __ expectClosingParenthesis {
+  = inlineSpace* "(" __ list:parenthesesArgumentList? __ expectClosingParenthesis {
       return annotate(list ?? [undefined], location());
     }
 
@@ -764,7 +789,7 @@ slashFollows
 
 spreadElement
   = ellipsis __ value:expectPipelineExpression {
-      return annotate([ops.spread, value], location());
+      return annotate([markers.spread, value], location());
     }
 
 stringLiteral "string"