@weborigami/language 0.0.52 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.52",
-    "@weborigami/types": "0.0.52",
+    "@weborigami/async-tree": "0.0.53",
+    "@weborigami/types": "0.0.53",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/origami.pegjs

@@ -7,7 +7,7 @@
 //
 
 import * as ops from "../runtime/ops.js";
-import { makeFunctionCall, makeObject, makePipeline, makeTemplate } from "./parserHelpers.js";
+import { makeArray, makeFunctionCall, makeObject, makePipeline, makeTemplate } from "./parserHelpers.js";
 
 // If a parse result is an object that will be evaluated at runtime, attach the
 // location of the source code that produced it for debugging and error messages.
@@ -39,10 +39,18 @@ args "function arguments"
     }
 
 array "array"
-  = "[" __ list:list? __ closingBracket {
-      return annotate([ops.array, ...(list ?? [])], location());
+  = "[" __ entries:arrayEntries? __ closingBracket {
+      return annotate(makeArray(entries ?? []), location());
     }
 
+// A separated list of array entries
+arrayEntries
+  = @arrayEntry|1.., separator| separator?
+
+arrayEntry
+  = spread
+  / expr
+
 // Something that can be called. This is more restrictive than the `expr`
 // parser; it doesn't accept regular function calls.
 callTarget "function call"

package/src/compiler/parse.js

@@ -12,7 +12,7 @@
 //
 
 import * as ops from "../runtime/ops.js";
-import { makeFunctionCall, makeObject, makePipeline, makeTemplate } from "./parserHelpers.js";
+import { makeArray, makeFunctionCall, makeObject, makePipeline, makeTemplate } from "./parserHelpers.js";
 
 // If a parse result is an object that will be evaluated at runtime, attach the
 // location of the source code that produced it for debugging and error messages.
@@ -193,7 +193,7 @@ function peg$parse(input, options) {
   var peg$FAILED = {};
   var peg$source = options.grammarSource;
 
-  var peg$startRuleFunctions = { __: peg$parse__, absoluteFilePath: peg$parseabsoluteFilePath, args: peg$parseargs, array: peg$parsearray, callTarget: peg$parsecallTarget, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParen: peg$parseclosingParen, comment: peg$parsecomment, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, escapedChar: peg$parseescapedChar, expr: peg$parseexpr, expression: peg$parseexpression, float: peg$parsefloat, functionComposition: peg$parsefunctionComposition, group: peg$parsegroup, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParensArgs: peg$parseimplicitParensArgs, inlineSpace: peg$parseinlineSpace, integer: peg$parseinteger, lambda: peg$parselambda, leadingSlashPath: peg$parseleadingSlashPath, list: peg$parselist, multiLineComment: peg$parsemultiLineComment, newLine: peg$parsenewLine, number: peg$parsenumber, object: peg$parseobject, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectProperty: peg$parseobjectProperty, parameterizedLambda: peg$parseparameterizedLambda, parensArgs: peg$parseparensArgs, pipeline: peg$parsepipeline, path: peg$parsepath, pathKey: peg$parsepathKey, protocolCall: peg$parseprotocolCall, protocol: peg$parseprotocol, reservedProtocol: peg$parsereservedProtocol, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, shebang: peg$parseshebang, sign: peg$parsesign, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spread: peg$parsespread, step: peg$parsestep, start: peg$parsestart, string: peg$parsestring, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentContents: peg$parsetemplateDocumentContents, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralContents: peg$parsetemplateLiteralContents, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, tree: peg$parsetree, treeAssignment: peg$parsetreeAssignment, treeEntries: peg$parsetreeEntries, treeEntry: peg$parsetreeEntry, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
+  var peg$startRuleFunctions = { __: peg$parse__, absoluteFilePath: peg$parseabsoluteFilePath, args: peg$parseargs, array: peg$parsearray, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, callTarget: peg$parsecallTarget, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParen: peg$parseclosingParen, comment: peg$parsecomment, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, escapedChar: peg$parseescapedChar, expr: peg$parseexpr, expression: peg$parseexpression, float: peg$parsefloat, functionComposition: peg$parsefunctionComposition, group: peg$parsegroup, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParensArgs: peg$parseimplicitParensArgs, inlineSpace: peg$parseinlineSpace, integer: peg$parseinteger, lambda: peg$parselambda, leadingSlashPath: peg$parseleadingSlashPath, list: peg$parselist, multiLineComment: peg$parsemultiLineComment, newLine: peg$parsenewLine, number: peg$parsenumber, object: peg$parseobject, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectProperty: peg$parseobjectProperty, parameterizedLambda: peg$parseparameterizedLambda, parensArgs: peg$parseparensArgs, pipeline: peg$parsepipeline, path: peg$parsepath, pathKey: peg$parsepathKey, protocolCall: peg$parseprotocolCall, protocol: peg$parseprotocol, reservedProtocol: peg$parsereservedProtocol, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, shebang: peg$parseshebang, sign: peg$parsesign, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spread: peg$parsespread, step: peg$parsestep, start: peg$parsestart, string: peg$parsestring, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentContents: peg$parsetemplateDocumentContents, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralContents: peg$parsetemplateLiteralContents, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, tree: peg$parsetree, treeAssignment: peg$parsetreeAssignment, treeEntries: peg$parsetreeEntries, treeEntry: peg$parsetreeEntry, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
   var peg$startRuleFunction = peg$parse__;
 
   var peg$c0 = "//";
@@ -329,8 +329,8 @@ function peg$parse(input, options) {
   var peg$f2 = function(path) {
       return annotate([ops.traverse, ...path], location());
     };
-  var peg$f3 = function(list) {
-      return annotate([ops.array, ...(list ?? [])], location());
+  var peg$f3 = function(entries) {
+      return annotate(makeArray(entries ?? []), location());
     };
   var peg$f4 = function() {
     error("Expected right curly brace");
@@ -682,7 +682,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parse__();
-      s3 = peg$parselist();
+      s3 = peg$parsearrayEntries();
       if (s3 === peg$FAILED) {
         s3 = null;
       }
@@ -708,6 +708,60 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parsearrayEntries() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = [];
+    s3 = peg$parsearrayEntry();
+    while (s3 !== peg$FAILED) {
+      s2.push(s3);
+      s3 = peg$currPos;
+      s4 = peg$parseseparator();
+      if (s4 !== peg$FAILED) {
+        s4 = peg$parsearrayEntry();
+        if (s4 === peg$FAILED) {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        } else {
+          s3 = s4;
+        }
+      } else {
+        s3 = s4;
+      }
+    }
+    if (s2.length < 1) {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    } else {
+      s1 = s2;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseseparator();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      s0 = s1;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsearrayEntry() {
+    var s0;
+
+    s0 = peg$parsespread();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsepipeline();
+    }
+
+    return s0;
+  }
+
   function peg$parsecallTarget() {
     var s0, s1;
 
@@ -3146,6 +3200,8 @@ const peg$allowedStartRules = [
   "absoluteFilePath",
   "args",
   "array",
+  "arrayEntries",
+  "arrayEntry",
   "callTarget",
   "closingBrace",
   "closingBracket",

package/src/compiler/parserHelpers.js

@@ -2,6 +2,38 @@ import * as ops from "../runtime/ops.js";
 
 // Parser helpers
 
+export function makeArray(entries) {
+  let currentEntries = [];
+  const spreads = [];
+
+  for (const value of entries) {
+    if (Array.isArray(value) && value[0] === ops.spread) {
+      if (currentEntries.length > 0) {
+        spreads.push([ops.array, ...currentEntries]);
+        currentEntries = [];
+      }
+      spreads.push(...value.slice(1));
+    } else {
+      currentEntries.push(value);
+    }
+  }
+
+  // Finish any current entries.
+  if (currentEntries.length > 0) {
+    spreads.push([ops.array, ...currentEntries]);
+    currentEntries = [];
+  }
+
+  if (spreads.length > 1) {
+    return [ops.merge, ...spreads];
+  }
+  if (spreads.length === 1) {
+    return spreads[0];
+  } else {
+    return [ops.array];
+  }
+}
+
 export function makeFunctionCall(target, chain) {
   let value = target;
   // The chain is an array of arguments (which are themselves arrays). We

package/src/runtime/mergeTrees.js

@@ -33,6 +33,11 @@ export default async function mergeTrees(...trees) {
     return mergeObjects(...unpacked);
   }
 
+  // If all trees are arrays, return an array.
+  if (unpacked.every((tree) => Array.isArray(tree))) {
+    return unpacked.flat();
+  }
+
   // If a tree can take a scope, give it one that includes the other trees and
   // the current scope.
   const scopedTrees = unpacked.map((tree) => {

package/test/compiler/parse.test.js

@@ -17,6 +17,11 @@ describe("Origami parser", () => {
     assertParse("array", "[]", [ops.array]);
     assertParse("array", "[1, 2, 3]", [ops.array, 1, 2, 3]);
     assertParse("array", "[ 1 , 2 , 3 ]", [ops.array, 1, 2, 3]);
+    assertParse("array", "[ 1, ...[2, 3]]", [
+      ops.merge,
+      [ops.array, 1],
+      [ops.array, 2, 3],
+    ]);
   });
 
   test("treeAssignment", () => {

package/test/runtime/mergeTrees.test.js

@@ -66,4 +66,9 @@ describe("mergeTrees", () => {
       d: 4,
     });
   });
+
+  test("if all arguments are arrays, result is an array", async () => {
+    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
+    assert.deepEqual(result, [1, 2, 3, 4]);
+  });
 });