@weborigami/language 0.0.38 → 0.0.40

package/index.ts

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

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.8.10",
-    "typescript": "5.2.2"
+    "@types/node": "20.11.7",
+    "typescript": "5.3.3"
   },
   "dependencies": {
-    "@weborigami/types": "*",
-    "@weborigami/async-tree": "*",
+    "@weborigami/async-tree": "0.0.40",
+    "@weborigami/types": "0.0.40",
     "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,27 +15,27 @@ __
   = (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
+argsChain "function arguments"
   = parts:(parensArgs / leadingSlashPath)+ { return parts; }
 
 // 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
@@ -46,23 +46,23 @@ callTarget
   / 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
@@ -87,21 +87,21 @@ 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
+functionComposition "function composition"
   = target:callTarget chain:argsChain { return makeFunctionCall(target, chain); }
 
 // An expression in parentheses: `(foo)`
-group
+group "parenthetical group"
   = "(" __ @expr __ ")"
 
-identifier
+identifier "identifier"
   = chars:identifierChar+ { return chars.join(""); }
 
 identifierChar
@@ -109,7 +109,7 @@ identifierChar
   / escapedChar
 
 // 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 +117,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
+lambda "lambda function"
   = "=" __ expr:expr { return [ops.lambda, 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 +147,7 @@ newLine
   / "\r"
 
 // A number
-number
+number "number"
   = float
   / integer
 
@@ -154,7 +155,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,7 +165,7 @@ objectProperties
     }
 
 // A single object property with key and value: `x: 1`
-objectProperty
+objectProperty "object property"
   = @identifier __ ":" __ @expr
 
 objectPropertyOrShorthand
@@ -172,7 +173,7 @@ objectPropertyOrShorthand
   / key:identifier { return [key, [ops.scope, key]]; }
 
 // Function arguments in parentheses
-parensArgs
+parensArgs "function arguments in parentheses"
   = "(" __ list:list? ")" { return list ?? [undefined]; }
 
 separator
@@ -183,36 +184,37 @@ 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
   / "treehttps" { return ops.treeHttps; }
   / "treehttp" { return ops.treeHttp; }
-  / "tree" { return ops.treeHttps; } // Shorthand alias
+  / "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
@@ -221,13 +223,13 @@ 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"
+templateDocument "template"
   = contents:templateDocumentContents { return [ops.lambda, contents]; }
 
 // Template documents can contain backticks at the top level.
@@ -238,11 +240,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
@@ -257,14 +259,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