@weborigami/language 0.2.10 → 0.2.12

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";
@@ -13,7 +14,6 @@ export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctio
 export * as moduleCache from "./src/runtime/moduleCache.js";
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
 export * as symbols from "./src/runtime/symbols.js";
-export { default as taggedTemplate } from "./src/runtime/taggedTemplate.js";
 export { default as taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -8,13 +8,13 @@
   "devDependencies": {
     "@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.10",
-    "@weborigami/types": "0.2.10",
-    "watcher": "2.3.1"
+    "@weborigami/async-tree": "0.2.12",
+    "@weborigami/types": "0.2.12",
+    "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/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";
 
 }}
 
@@ -206,6 +209,18 @@ expectDoubleQuote
       error("Expected closing quote");
     }
 
+expectExpression
+  = expression
+  / .? {
+      error("Expected an Origami expression");
+    }
+
+expectFrontDelimiter
+  = frontDelimiter
+  / .? {
+      error("Expected \"---\"");
+    }
+
 expectGuillemet
   = '»'
   / .? {
@@ -239,6 +254,27 @@ 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 expectClosingParenthesis {
@@ -619,10 +655,10 @@ 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)* {
+// 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()
@@ -633,15 +669,25 @@ templateDocument "template"
       );
     }
 
-// 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)* expectBacktick {
@@ -659,7 +705,7 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" expression:expression "}" {
+  = "${" expression:expectExpression "}" {
       return annotate(expression, location());
     }