@weborigami/language 0.2.9 → 0.2.11

package/main.js

@@ -1,6 +1,7 @@
 export * from "./src/runtime/internal.js";
 
 export * as compile from "./src/compiler/compile.js";
+export { default as isOrigamiFrontMatter } from "./src/compiler/isOrigamiFrontMatter.js";
 export * from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.13.5",
+    "@types/node": "22.13.13",
     "peggy": "4.2.0.",
-    "typescript": "5.8.2",
-    "yaml": "2.7.0"
+    "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.9",
-    "@weborigami/types": "0.2.9",
-    "watcher": "2.3.1"
+    "@weborigami/async-tree": "0.2.11",
+    "@weborigami/types": "0.2.11",
+    "watcher": "2.3.1",
+    "yaml": "2.7.0"
   },
   "scripts": {
     "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",

package/src/compiler/isOrigamiFrontMatter.js

@@ -0,0 +1,26 @@
+/**
+ * Return true if the given text is Origami front matter
+ *
+ * Our heurstic is to see skip any initial alphanumeric or underscore
+ * characters, then see if the next character is a parenthesis, dot, slash,
+ * curly brace, or equals sign. If so, we assume this is an Origami expression.
+ *
+ * The goal is to identify Origami front matter like:
+ *
+ * ```
+ *   fn(x)              function call
+ *   index.ori()        file extension
+ *   src/data.json      file path
+ *   // Hello           comment
+ *   { a: 1 }           object literal
+ * ```
+ *
+ * These are generally invalid ways to start YAML. The last is valid YAML, but
+ * Origami supports the same syntax for basic object literals so interpreting as
+ * Origami should generally be acceptable.
+ *
+ * @param {string} text
+ */
+export default function isOrigamiFrontMatter(text) {
+  return /^[ \t\r\n]*[A-Za-z0-9_]*[\(\.\/\{=]/.test(text);
+}

package/src/compiler/optimize.js

@@ -34,7 +34,7 @@ export default function optimize(
   switch (fn) {
     case ops.lambda:
       const parameters = args[0];
-      additionalLocalNames = parameters;
+      additionalLocalNames = parameters.map((param) => param[1]);
       break;
 
     case ops.literal:
@@ -61,7 +61,7 @@ export default function optimize(
       } else if (enableCaching && !locals[normalizedKey]) {
         // Upgrade to cached external scope reference
         return annotate(
-          [ops.external, key, [ops.scope, key], cache],
+          [ops.external, key, annotate([ops.scope, key], code.location), cache],
           code.location
         );
       } else if (fn === undetermined) {
@@ -110,13 +110,15 @@ export default function optimize(
   }
 
   // Optimize children
-  const optimized = code.map((child) => {
-    if (Array.isArray(child) && "location" in child) {
+  const optimized = code.map((child, index) => {
+    // Don't optimize lambda parameter names
+    if (fn === ops.lambda && index === 1) {
+      return child;
+    } else if (Array.isArray(child) && "location" in child) {
       // Review: This currently descends into arrays that are not instructions,
-      // such as the parameters of a lambda. This should be harmless, but it'd
+      // such as the entries of an ops.object. This should be harmless, but it'd
       // be preferable to only descend into instructions. This would require
-      // surrounding ops.lambda parameters with ops.literal, and ops.object
-      // entries with ops.array.
+      // surrounding ops.object entries with ops.array.
       return optimize(
         /** @type {AnnotatedCode} */ (child),
         enableCaching,

package/src/compiler/origami.pegjs

@@ -14,6 +14,7 @@
 import * as ops from "../runtime/ops.js";
 import {
   annotate,
+  applyMacro,
   downgradeReference,
   makeArray,
   makeBinaryOperation,
@@ -24,8 +25,10 @@ import {
   makeProperty,
   makeReference,
   makeTemplate,
-  makeUnaryOperation
+  makeUnaryOperation,
+  makeYamlObject
 } from "./parserHelpers.js";
+import isOrigamiFrontMatter from "./isOrigamiFrontMatter.js";
 
 }}
 
@@ -50,7 +53,7 @@ arguments "function arguments"
   / templateLiteral
 
 arrayLiteral "array"
-  = "[" __ entries:arrayEntries? __ closingBracket {
+  = "[" __ entries:arrayEntries? __ expectClosingBracket {
       return makeArray(entries ?? [], location());
     }
 
@@ -69,13 +72,12 @@ arrayEntry
     }
 
 arrowFunction
-  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipelineExpression {
-      const lambdaParameters = annotate(parameters ?? [], location());
+  = "(" __ parameters:parameterList? __ ")" __ doubleArrow __ pipeline:expectPipelineExpression {
+      const lambdaParameters = parameters ?? annotate([], location());
       return annotate([ops.lambda, lambdaParameters, pipeline], location());
     }
-  / identifier:identifier __ doubleArrow __ pipeline:pipelineExpression {
-      const lambdaParameters = annotate([identifier], location())
-      return annotate([ops.lambda, lambdaParameters, pipeline], location());
+  / parameter:parameterSingleton __ doubleArrow __ pipeline:expectPipelineExpression {
+      return annotate([ops.lambda, parameter, pipeline], location());
     }
   / conditionalExpression
 
@@ -110,30 +112,6 @@ callExpression "function call"
       return tail.reduce(makeCall, head);
     }
 
-// Required closing curly brace. We use this for the `object` term: if the
-// parser sees a left curly brace, here we must see a right curly brace.
-closingBrace
-  = "}"
-  / .? {
-      error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
-    }
-
-// Required closing bracket
-closingBracket
-  = "]"
-  / .? {
-      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
-// sees a left parenthesis, here we must see a right parenthesis.
-closingParenthesis
-  = ")"
-  / .? {
-      error("Expected right parenthesis");
-    }
-
 // A comma-separated list of expressions: `x, y, z`
 commaExpression
   // The commas are required, but the list can have a single item.
@@ -171,7 +149,7 @@ digits
 doubleArrow = "⇒" / "=>"
 
 doubleQuoteString "double quote string"
-  = '"' chars:doubleQuoteStringChar* '"' {
+  = '"' chars:doubleQuoteStringChar* expectDoubleQuote {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -201,6 +179,67 @@ escapedChar "backslash-escaped character"
   / "\\v" { return "\v"; }
   / "\\" @.
 
+expectBacktick
+  = "`"
+  / .? {
+      error("Expected closing backtick");
+    }
+
+expectClosingBrace
+  = "}"
+  / .? {
+      error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
+    }
+
+expectClosingBracket
+  = "]"
+  / .? {
+      error("Expected right bracket");
+    }
+
+expectClosingParenthesis
+  = ")"
+  / .? {
+      error("Expected right parenthesis");
+    }
+
+expectDoubleQuote
+  = '"'
+  / .? {
+      error("Expected closing quote");
+    }
+
+expectExpression
+  = expression
+  / .? {
+      error("Expected an Origami expression");
+    }
+
+expectFrontDelimiter
+  = frontDelimiter
+  / .? {
+      error("Expected \"---\"");
+    }
+
+expectGuillemet
+  = '»'
+  / .? {
+      error("Expected closing guillemet");
+    }
+
+expectSingleQuote
+  = "'"
+  / .? {
+      error("Expected closing quote");
+    }
+
+// Required expression
+expectPipelineExpression
+  = pipelineExpression
+  / .? {
+      error("Expected an expression");
+    }
+
 exponentiationExpression
   = left:unaryExpression right:(__ "**" __ @exponentiationExpression)? {
       return right ? annotate([ops.exponentiation, left, right], location()) : left;
@@ -215,14 +254,35 @@ floatLiteral "floating-point number"
       return annotate([ops.literal, parseFloat(text())], location());
     }
 
+// Marker for the beginning or end of front matter
+frontDelimiter
+  = "---\n"
+
+// Origami front matter
+frontMatterExpression
+  // If we detect Origami front matter, we need to see an expression
+  = frontDelimiter &{
+    return isOrigamiFrontMatter(input.slice(location().end.offset))
+  } @expectExpression expectFrontDelimiter
+
+frontMatterText
+  = chars:( !frontDelimiter @. )* {
+    return chars.join("");
+  }
+
+frontMatterYaml "YAML front matter"
+  = frontDelimiter yaml:frontMatterText frontDelimiter {
+    return makeYamlObject(yaml, location());
+  }
+
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" expression:expression closingParenthesis {
+  = "(" expression:expression expectClosingParenthesis {
       return annotate(downgradeReference(expression), location());
     }
 
 guillemetString "guillemet string"
-  = '«' chars:guillemetStringChar* '»' {
+  = '«' chars:guillemetStringChar* expectGuillemet {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -254,11 +314,6 @@ identifierChar
   / @'-' !'>' // Accept a hyphen but not in a single arrow combination
   / escapedChar
 
-identifierList
-  = list:identifier|1.., separator| separator? {
-      return annotate(list, location());
-    }
-
 implicitParenthesesCallExpression "function call with implicit parentheses"
   = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
       return args ? makeCall(head, args) : head;
@@ -350,7 +405,7 @@ nullishCoalescingExpression
 
 // An object literal: `{foo: 1, bar: 2}`
 objectLiteral "object literal"
-  = "{" __ entries:objectEntries? __ closingBrace {
+  = "{" __ entries:objectEntries? __ expectClosingBrace {
       return makeObject(entries ?? [], location());
     }
 
@@ -368,7 +423,7 @@ objectEntry
 
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
-  = key:objectKey __ "=" __ pipeline:pipelineExpression {
+  = key:objectKey __ "=" __ pipeline:expectPipelineExpression {
       return annotate(
         makeProperty(key, annotate([ops.getter, pipeline], location())),
         location()
@@ -384,7 +439,7 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = key:objectKey __ ":" __ pipeline:pipelineExpression {
+  = key:objectKey __ ":" __ pipeline:expectPipelineExpression {
       return annotate(makeProperty(key, pipeline), location());
     }
 
@@ -404,9 +459,28 @@ objectPublicKey
     return string[1];
   }
 
+parameter
+  = identifier:identifier {
+      return annotate([ops.literal, identifier], location());
+    }
+
+parameterList
+  = list:parameter|1.., separator| separator? {
+      return annotate(list, location());
+    }
+
+// A list with a single identifier
+parameterSingleton
+  = identifier:identifier {
+      return annotate(
+        [annotate([ops.literal, identifier], location())],
+        location()
+      );
+    }
+
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
-  = "(" __ list:list? __ ")" {
+  = "(" __ list:list? __ expectClosingParenthesis {
       return annotate(list ?? [undefined], location());
     }
 
@@ -535,7 +609,10 @@ shiftOperator
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
   = "=" !"=" __ definition:implicitParenthesesCallExpression {
-      const lambdaParameters = annotate(["_"], location());
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
       return annotate([ops.lambda, lambdaParameters, definition], location());
     }
   / implicitParenthesesCallExpression
@@ -548,7 +625,7 @@ singleLineComment
   = "//" [^\n\r]* { return null; }
 
 singleQuoteString "single quote string"
-  = "'" chars:singleQuoteStringChar* "'" {
+  = "'" chars:singleQuoteStringChar* expectSingleQuote {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -578,29 +655,42 @@ stringLiteral "string"
   / singleQuoteString
   / guillemetString
 
-// A top-level document defining a template. This is the same as a template
-// literal, but can contain backticks at the top level.
-templateDocument "template"
-  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
-      const lambdaParameters = annotate(["_"], location());
+// The body of a template document is a kind of template literal that can
+// contain backticks at the top level.
+templateBody "template"
+  = head:templateBodyText tail:(templateSubstitution templateBodyText)* {
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
       return annotate(
         [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
         location()
       );
     }
 
-// Template documents can contain backticks at the top level.
-templateDocumentChar
+// Template document bodies can contain backticks at the top level
+templateBodyChar
   = !("${") @textChar
 
-templateDocumentText "template text"
-  = chars:templateDocumentChar* {
+templateBodyText "template text"
+  = chars:templateBodyChar* {
       return annotate([ops.literal, chars.join("")], location());
     }
 
+templateDocument "template document"
+  = front:frontMatterExpression __ body:templateBody {
+      return annotate(applyMacro(front, "@template", body), location());
+    }
+  / front:frontMatterYaml? body:templateBody {
+      return front
+        ? annotate([ops.document, front, body], location())
+        : annotate(body, location());
+    }
+
 // A backtick-quoted template literal
 templateLiteral "template literal"
-  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* "`" {
+  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
       return makeTemplate(ops.template, head, tail, location());
     }
 
@@ -615,7 +705,7 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" expression:expression "}" {
+  = "${" expression:expectExpression "}" {
       return annotate(expression, location());
     }