@weborigami/language 0.0.64 → 0.0.65-beta.2

package/index.ts

@@ -3,13 +3,16 @@ import { Packed } from "@weborigami/async-tree";
 export * from "./main.js";
 
 /**
- * A chunk of compiled Origami code. This is just an Array with an additional
- * `source` property.
+ * A chunk of compiled Origami code. This is just an array with an additional
+ * `location` property.
  */
-interface ArrayWithSource extends Array<any> {
-  source?: Source;
-}
-export type Code = ArrayWithSource;
+export type Code = Array<any> & {
+  location: {
+    source: Source;
+    start: Position;
+    end: Position;
+  };
+};
 
 /**
  * A class constructor is an object with a `new` method that returns an
@@ -26,6 +29,14 @@ export type ExtensionHandler = {
   unpack?: UnpackFunction;
 }
 
+export type ParseResult = Code | string | number;
+
+export type Position = {
+  column: number;
+  line: number;
+  offset: number;
+}
+
 /**
  * A mixin is a function that takes an existing class and returns a new class.
  *
@@ -40,11 +51,11 @@ export type Mixin<MixinMembers> = <T>(
 
 /**
  * Source code representation used by the parser.
-*/
+ */
 export type Source = {
-  name: string;
+  name?: string;
   text: string;
-  url: URL;  
+  url?: URL;
 }
 
 /**

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.64",
+  "version": "0.0.65-beta.2",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.14.9",
+    "@types/node": "22.5.4",
     "peggy": "4.0.3",
-    "typescript": "5.5.3"
+    "typescript": "5.5.4"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.64",
-    "@weborigami/types": "0.0.64",
+    "@weborigami/async-tree": "0.0.65-beta.2",
+    "@weborigami/types": "0.0.65-beta.2",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -8,11 +8,11 @@ function compile(source, startRule) {
   // Trim whitespace from template blocks before we begin lexing, as our
   // heuristics are non-local and hard to implement in our parser.
   const preprocessed = trimTemplateWhitespace(source.text);
-  const code = parse(preprocessed, {
+  const parseResult = parse(preprocessed, {
     grammarSource: source,
     startRule,
   });
-  const fn = createExpressionFunction(code);
+  const fn = createExpressionFunction(parseResult);
   return fn;
 }
 

package/src/compiler/origami.pegjs

@@ -7,16 +7,14 @@
 //
 
 import * as ops from "../runtime/ops.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.
-function annotate(parseResult, location) {
-  if (typeof parseResult === "object" && parseResult !== null) {
-    parseResult.location = location;
-  }
-  return parseResult;
-}
+import {
+  annotate,
+  makeArray,
+  makeFunctionCall,
+  makeObject,
+  makePipeline,
+  makeTemplate
+} from "./parserHelpers.js";
 
 }}
 
@@ -45,7 +43,9 @@ array "array"
 
 // A separated list of array entries
 arrayEntries
-  = @arrayEntry|1.., separator| separator?
+  = entries:arrayEntry|1.., separator| separator? {
+      return annotate(entries, location());
+    }
 
 arrayEntry
   = spread
@@ -68,15 +68,15 @@ callTarget "function call"
 closingBrace
   = "}"
   / .? {
-    error("Expected right curly brace");
-  }
+      error("Expected right curly brace");
+    }
 
 // Required closing bracket
 closingBracket
   = "]"
   / .? {
-    error("Expected right bracket");
-  }
+      error("Expected right bracket");
+    }
 
 // Required closing parenthesis. We use this for the `group` term: it's the last
 // term in the `step` parser that starts with a parenthesis, so if that parser
@@ -84,8 +84,8 @@ closingBracket
 closingParen
   = ")"
   / .? {
-    error("Expected right parenthesis");
-  }
+      error("Expected right parenthesis");
+    }
 
 // A single line comment
 comment "comment"
@@ -106,7 +106,14 @@ doubleQuoteStringChar
 ellipsis = "..." / "…" // Unicode ellipsis
 
 escapedChar "backslash-escaped character"
-  = "\\" @.
+  = "\\0" { return "\0"; }
+  / "\\b" { return "\b"; }
+  / "\\f" { return "\f"; }
+  / "\\n" { return "\n"; }
+  / "\\r" { return "\r"; }
+  / "\\t" { return "\t"; }
+  / "\\v" { return "\v"; }
+  / "\\" @.
 
 // An Origami expression, no leading/trailing whitespace
 expr
@@ -126,15 +133,17 @@ float "floating-point number"
 // of function calls, like `fn(arg1)(arg2)(arg3)`.
 functionComposition "function composition"
   = target:callTarget chain:args* end:implicitParensArgs? {
-    if (end) {
-      chain.push(end);
+      if (end) {
+        chain.push(end);
+      }
+      return annotate(makeFunctionCall(target, chain), location());
     }
-    return annotate(makeFunctionCall(target, chain), location());
-  }
 
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" __ @expr __ closingParen
+  = "(" __ expr:expr __ closingParen {
+      return annotate(expr, location());
+    }
 
 guillemetString "guillemet string"
   = '«' chars:guillemetStringChar* '»' { return chars.join(""); }
@@ -157,7 +166,9 @@ identifierChar
   / escapedChar
 
 identifierList
-  = @identifier|1.., separator| separator?
+  = list:identifier|1.., separator| separator? {
+      return annotate(list, location());
+    }
 
 identifierOrString
   = identifier
@@ -166,7 +177,10 @@ identifierOrString
 implicitParensArgs "arguments with implicit parentheses"
   // Implicit parens args are a separate list of `step`, not `expr`, because
   // they can't contain a pipeline.
-  = inlineSpace+ @step|1.., separator| separator?
+  = inlineSpace+ args:step|1.., separator| separator? {
+      /* Stuff */
+      return annotate(args, location());
+    }
 
 inlineSpace
   = [ \t]
@@ -184,12 +198,18 @@ lambda "lambda function"
 
 // A path that begins with a slash: `/foo/bar`
 leadingSlashPath "path with a leading slash"
-  = "/" @path
-  / "/" { return annotate([""], location()); }
+  = "/" path:path {
+      return annotate(path, location());
+    }
+  / "/" {
+      return annotate([""], location());
+    }
 
 // A separated list of expressions
 list "list"
-  = @expr|1.., separator| separator?
+  = list:expr|1.., separator| separator? {
+      return annotate(list, location());
+    }
 
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
@@ -212,7 +232,9 @@ object "object literal"
 
 // A separated list of object entries
 objectEntries
-  = @objectEntry|1.., separator| separator?
+  = entries:objectEntry|1.., separator| separator? {
+      return annotate(entries, location());
+    }
 
 objectEntry
   = spread
@@ -223,8 +245,8 @@ objectEntry
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
   = key:objectKey __ "=" __ value:expr {
-    return annotate([key, [ops.getter, value]], location());
-  }
+      return annotate([key, [ops.getter, value]], location());
+    }
 
 // A standalone reference inside an object literal: `foo`
 objectIdentifier "object identifier"
@@ -238,17 +260,19 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = @objectKey __ ":" __ @expr
+  = key:objectKey __ ":" __ value:expr {
+      return annotate([key, value], location());  
+    }
 
 parameterizedLambda
   = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ expr:expr {
-    return annotate([ops.lambda, parameters ?? [], expr], location());
-  }
+      return annotate([ops.lambda, parameters ?? [], expr], location());
+    }
 
 // Function arguments in parentheses
 parensArgs "function arguments in parentheses"
   = "(" __ list:list? __ ")" {
-      return list ?? annotate([undefined], location());
+      return annotate(list ?? [undefined], location());
     }
 
 pipeline
@@ -258,7 +282,9 @@ pipeline
 
 // A slash-separated path of keys
 path "slash-separated path"
-  = pathKey|1.., "/"|
+  = path:pathKey|1.., "/"| {
+      return annotate(path, location());
+    }
 
 // A single key in a slash-separated path
 pathKey "path element"
@@ -318,7 +344,9 @@ singleQuoteStringChar
   = !("'" / newLine) @textChar
 
 spread
-  = ellipsis expr:expr { return [ops.spread, expr]; }
+  = ellipsis expr:expr {
+      return annotate([ops.spread, expr], location());
+    }
 
 // A single step in a pipeline, or a top-level expression
 step
@@ -372,7 +400,9 @@ templateDocumentText "template text"
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
-  = "`" @templateLiteralContents "`"
+  = "`" contents:templateLiteralContents "`" {
+      return annotate(contents, location());
+    }
 
 templateLiteralChar
   = !("`" / "${") @textChar
@@ -389,10 +419,13 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" __ @expr __ "}"
+  = "${" __ expr:expr __ "}" {
+      return annotate(expr, location());
+    }
 
 textChar
-  = escapedChar / .
+  = escapedChar
+  / .
 
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __

package/src/compiler/parse.d.ts

@@ -1,3 +1,3 @@
-import { Code } from "../../index.ts";
+import { ParseResult } from "../../index.ts";
 
-export function parse(input: string, options: any): Code;
+export function parse(input: string, options: any): ParseResult;