@weborigami/language 0.0.39 → 0.0.41

package/index.ts

@@ -15,6 +15,7 @@ export type Constructor<T> = new (...args: any[]) => T;
 export type FileUnpackFunction = (
   input: StringLike,
   options?: {
+    compiler?: any,
     key?: any,
     parent?: AsyncTree | null
   }

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.11.3",
+    "@types/node": "20.11.7",
     "typescript": "5.3.3"
   },
   "dependencies": {
-    "@weborigami/types": "*",
-    "@weborigami/async-tree": "*",
+    "@weborigami/async-tree": "0.0.41",
+    "@weborigami/types": "0.0.41",
     "peggy": "3.0.2",
     "watcher": "2.3.0"
   },
   "scripts": {
     "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",
     "prepublishOnly": "npm run build",
-    "test": "node --test",
+    "test": "node --test --test-reporter=spec",
     "typecheck": "tsc"
   }
 }

package/src/compiler/origami.pegjs

@@ -15,54 +15,55 @@ __
   = (inlineSpace / newLine / comment)*  { return ""; }
 
 // A filesystem path that begins with a slash: `/foo/bar`
-absoluteFilePath
+absoluteFilePath "absolute file path"
   = path:leadingSlashPath { return [[ops.filesRoot], ...path]; }
 
-// A chain of arguments: `(arg1)(arg2)(arg3)`
-argsChain
-  = parts:(parensArgs / leadingSlashPath)+ { return parts; }
+args "function arguments"
+  = parensArgs
+  / path:leadingSlashPath { return [ops.traverse, ...path]; }
 
 // An assignment statement: `foo = 1`
-assignment
+assignment "tree assignment"
   = @identifier __ "=" __ @expr
 
 assignmentOrShorthand
   = assignment
   / key:identifier { return [key, [ops.inherited, key]]; }
 
-array
+array "array"
   = "[" __ list:list? "]" { return [ops.array, ...(list ?? [])]; }
 
 // Something that can be called. This is more restrictive than the `expr`
 // parser; it doesn't accept regular function calls.
-callTarget
+callTarget "function call"
   = absoluteFilePath
   / array
   / object
   / tree
   / lambda
+  / parameterizedLambda
   / protocolCall
   / group
   / scopeReference
 
 // A single line comment
-comment
+comment "comment"
   = "#" [^\n\r]*
 
 digits
   = @[0-9]+
 
-doubleQuoteString
+doubleQuoteString "double quote string"
   = '"' chars:doubleQuoteStringChar* '"' { return chars.join(""); }
 
 doubleQuoteStringChar
   = !('"' / newLine) @textChar
 
-escapedChar
+escapedChar "backslash-escaped character"
   = "\\" @.
 
 // An Origami expression, no leading/trailing whitespace
-expr
+expr "expression"
   // Try function calls first, as they can start with expression types that
   // follow (array, object, etc.); we want to parse the largest thing first.
   = implicitParensCall
@@ -73,8 +74,9 @@ expr
   / array
   / object
   / tree
-  / lambda
   / templateLiteral
+  / lambda
+  / parameterizedLambda
   / group
   / string
   / number
@@ -87,29 +89,35 @@ expr
 expression "Origami expression"
   = __ @expr __
 
-float
+float "floating-point number"
   = sign? digits? "." digits {
       return parseFloat(text());
     }
 
 // Parse a function and its arguments, e.g. `fn(arg)`, possibly part of a chain
 // of function calls, like `fn(arg1)(arg2)(arg3)`.
-functionComposition
-  = target:callTarget chain:argsChain { return makeFunctionCall(target, chain); }
+functionComposition "function composition"
+  // = target:callTarget chain:argsChain { return makeFunctionCall(target, chain); }
+  = target:callTarget chain:args+ { return makeFunctionCall(target, chain); }
 
 // An expression in parentheses: `(foo)`
-group
+group "parenthetical group"
   = "(" __ @expr __ ")"
 
-identifier
+identifier "identifier"
   = chars:identifierChar+ { return chars.join(""); }
 
 identifierChar
-  = [^(){}\[\],/:=\`"'\\# \t\n\r] // No unescaped whitespace or special chars
+  = [^(){}\[\]<>,/:=\`"'\\# \t\n\r] // No unescaped whitespace or special chars
   / escapedChar
 
+identifierList
+  = head:identifier tail:(separator @identifier)* separator? {
+    return [head].concat(tail);
+  }
+
 // A function call with implicit parentheses: `fn 1, 2, 3`
-implicitParensCall
+implicitParensCall "function call with implicit parentheses"
   = target:(functionComposition / callTarget) inlineSpace+ args:list {
       return [target, ...args];
     }
@@ -117,28 +125,29 @@ implicitParensCall
 // A host identifier that may include a colon and port number: `example.com:80`.
 // This is used as a special case at the head of a path, where we want to
 // interpret a colon as part of a text identifier.
-host
+host "HTTP/HTTPS host"
   = identifier (":" number)? { return text(); }
 
 inlineSpace
   = [ \t]
 
-integer
+integer "integer"
   = sign? digits {
       return parseInt(text());
     }
 
 // A lambda expression: `=foo()`
-lambda
-  = "=" __ expr:expr { return [ops.lambda, expr]; }
+lambda "lambda function"
+  = "=" __ expr:expr { return [ops.lambda, null, expr]; }
 
 // A path that begins with a slash: `/foo/bar`
-leadingSlashPath
+leadingSlashPath "path with a leading slash"
   = "/" @path
   / "/" { return [""]; }
 
 // A separated list of expressions
-list = head:expr tail:(separator @expr)* separator? { return [head].concat(tail); }
+list "list"
+  = head:expr tail:(separator @expr)* separator? { return [head].concat(tail); }
 
 newLine
   = "\n"
@@ -146,7 +155,7 @@ newLine
   / "\r"
 
 // A number
-number
+number "number"
   = float
   / integer
 
@@ -154,7 +163,7 @@ number
 //
 // TODO: Use Object.fromEntries with array of key/value pairs
 //
-object
+object "object literal"
   = "{" __ properties:objectProperties? "}" { return [ops.object, ...(properties ?? [])]; }
 
 // A separated list of object properties or shorthands
@@ -164,15 +173,20 @@ objectProperties
     }
 
 // A single object property with key and value: `x: 1`
-objectProperty
+objectProperty "object property"
   = @identifier __ ":" __ @expr
 
 objectPropertyOrShorthand
   = objectProperty
   / key:identifier { return [key, [ops.scope, key]]; }
 
+parameterizedLambda
+  = "(" __ parameters:identifierList? ")" __ ("=>"/"⇒") __ expr:expr {
+    return [ops.lambda, parameters ?? [], expr];
+  }
+
 // Function arguments in parentheses
-parensArgs
+parensArgs "function arguments in parentheses"
   = "(" __ list:list? ")" { return list ?? [undefined]; }
 
 separator
@@ -183,26 +197,26 @@ sign
   = [+\-]
 
 // A slash-separated path of keys
-path
+path "slash-separated path"
   = head:pathKey "/" tail:path { return [head].concat(tail); }
   / key:pathKey { return [key]; }
 
 // A single key in a slash-separated path
-pathKey
+pathKey "path element"
   = key:identifierChar* { return key.join(""); }
 
 // Parse a protocol call like `fn://foo/bar`.
 // There can be zero, one, or two slashes after the colon.
-protocolCall
+protocolCall "function call using protocol: syntax"
   = protocol:protocol ":" "/"|0..2| host:host path:leadingSlashPath? {
       return [protocol, host, ...(path ?? [])];
     }
 
-protocol
+protocol "protocol"
   = reservedProtocol
   / scopeReference
 
-reservedProtocol
+reservedProtocol "reserved protocol"
   = "https" { return ops.https; }
   / "http" { return ops.http; }
   / "package" { return [ops.scope, "@package"] } // Alias
@@ -210,10 +224,10 @@ reservedProtocol
   / "treehttp" { return ops.treeHttp; }
   / "tree" { return ops.treeHttps; } // Alias
 
-scopeReference
+scopeReference "scope reference"
   = key:identifier { return [ops.scope, key]; }
 
-singleQuoteString
+singleQuoteString "single quote string"
   = "'" chars:singleQuoteStringChar* "'" { return chars.join(""); }
 
 singleQuoteStringChar
@@ -222,14 +236,14 @@ singleQuoteStringChar
 start
   = number
 
-string
+string "string"
   = doubleQuoteString
   / singleQuoteString
 
 // A top-level document defining a template. This is the same as a template
 // literal, but can contain backticks at the top level.
-templateDocument "Origami template"
-  = contents:templateDocumentContents { return [ops.lambda, contents]; }
+templateDocument "template"
+  = contents:templateDocumentContents { return [ops.lambda, null, contents]; }
 
 // Template documents can contain backticks at the top level.
 templateDocumentChar
@@ -239,11 +253,11 @@ templateDocumentChar
 templateDocumentContents
   = parts:(templateDocumentText / templateSubstitution)* { return makeTemplate(parts); }
 
-templateDocumentText
+templateDocumentText "template text"
   = chars:templateDocumentChar+ { return chars.join(""); }
 
 // A backtick-quoted template literal
-templateLiteral
+templateLiteral "template literal"
   = "`" @templateLiteralContents "`"
 
 templateLiteralChar
@@ -258,14 +272,14 @@ templateLiteralText
   = chars:templateLiteralChar+ { return chars.join(""); }
 
 // A substitution in a template literal: `{{ fn() }}`
-templateSubstitution
+templateSubstitution "template substitution"
   = "{{" @expression "}}"
 
 textChar
   = escapedChar / .
 
 // A tree literal: `{ index.html = "Hello" }`
-tree
+tree "tree literal"
   = "{" __ assignments:treeAssignments? "}" { return [ops.tree, ...(assignments ?? [])]; }
 
 // A separated list of assignments or shorthands