@weborigami/language 0.2.2 → 0.2.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Miksovsky and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/main.js

@@ -13,5 +13,6 @@ export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctio
 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,19 +1,19 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.7.4",
-    "peggy": "4.0.3",
-    "typescript": "5.6.2",
-    "yaml": "2.5.1"
+    "@types/node": "22.10.2",
+    "peggy": "4.2.0.",
+    "typescript": "5.7.2",
+    "yaml": "2.6.1"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.2",
-    "@weborigami/types": "0.2.2",
+    "@weborigami/async-tree": "0.2.4",
+    "@weborigami/types": "0.2.4",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -5,7 +5,7 @@ import { parse } from "./parse.js";
 import { annotate, undetermined } from "./parserHelpers.js";
 
 function compile(source, options) {
-  const { startRule } = options;
+  const { macros, startRule } = options;
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
@@ -15,7 +15,7 @@ function compile(source, options) {
     startRule,
   });
   const cache = {};
-  const modified = transformScopeReferences(code, cache, enableCaching);
+  const modified = transformReferences(code, cache, enableCaching, macros);
   const fn = createExpressionFunction(modified);
   return fn;
 }
@@ -27,14 +27,34 @@ export function expression(source, options = {}) {
   });
 }
 
-// Transform any remaining undetermined references to scope references. At the
-// same time, transform those or explicit ops.scope calls to ops.external calls
-// unless they refer to local variables (variables defined by object literals or
-// lambda parameters).
-export function transformScopeReferences(
+export function program(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "program",
+  });
+}
+
+export function templateDocument(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "templateDocument",
+  });
+}
+
+/**
+ * Transform any remaining undetermined references to scope references.
+ *
+ * At the same time, transform those or explicit ops.scope calls to ops.external
+ * calls unless they refer to local variables (variables defined by object
+ * literals or lambda parameters).
+ *
+ * Also apply any macros to the code.
+ */
+export function transformReferences(
   code,
   cache,
   enableCaching,
+  macros,
   locals = {}
 ) {
   const [fn, ...args] = code;
@@ -45,7 +65,20 @@ export function transformScopeReferences(
     case ops.scope:
       const key = args[0];
       const normalizedKey = trailingSlash.remove(key);
-      if (enableCaching && !locals[normalizedKey]) {
+      if (macros?.[normalizedKey]) {
+        // Apply macro
+        const macroBody = macros[normalizedKey];
+        const modified = transformReferences(
+          macroBody,
+          cache,
+          enableCaching,
+          macros,
+          locals
+        );
+        // @ts-ignore
+        annotate(modified, code.location);
+        return modified;
+      } else if (enableCaching && !locals[normalizedKey]) {
         // Upgrade to cached external reference
         const modified = [ops.external, key, cache];
         // @ts-ignore
@@ -87,10 +120,11 @@ export function transformScopeReferences(
       // be preferable to only descend into instructions. This would require
       // surrounding ops.lambda parameters with ops.literal, and ops.object
       // entries with ops.array.
-      return transformScopeReferences(
+      return transformReferences(
         child,
         cache,
         enableCaching,
+        macros,
         updatedLocals
       );
     } else {
@@ -103,17 +137,3 @@ export function transformScopeReferences(
   }
   return modified;
 }
-
-export function program(source, options = {}) {
-  return compile(source, {
-    ...options,
-    startRule: "program",
-  });
-}
-
-export function templateDocument(source, options = {}) {
-  return compile(source, {
-    ...options,
-    startRule: "templateDocument",
-  });
-}

package/src/compiler/origami.pegjs

@@ -31,12 +31,12 @@ import {
 
 // A block of optional whitespace
 __
-  = (inlineSpace / newLine / comment)*  {
+  = whitespace*  {
     return null;
   }
 
 additiveExpression
-  = head:multiplicativeExpression tail:(__ @additiveOperator __ @multiplicativeExpression)* {
+  = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
       return annotate(tail.reduce(makeBinaryOperation, head), location());
     }
 
@@ -148,8 +148,8 @@ comment "comment"
 
 conditionalExpression
   = condition:logicalOrExpression tail:(__
-    "?" __ @pipelineExpression __
-    ":" __ @pipelineExpression)?
+    "?" __ @shorthandFunction __
+    ":" __ @shorthandFunction)?
     {
       if (!tail) {
         return condition;
@@ -310,7 +310,7 @@ multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
 multiplicativeExpression
-  = head:exponentiationExpression tail:(__ @multiplicativeOperator __ @exponentiationExpression)* {
+  = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
       return annotate(tail.reduce(makeBinaryOperation, head), location());
     }
 
@@ -571,20 +571,17 @@ stringLiteral "string"
 // 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"
-  = contents:templateDocumentContents {
-      return annotate([ops.lambda, ["_"], contents], location());
+  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
+      return annotate(
+        [ops.lambda, ["_"], makeTemplate(ops.templateIndent, head, tail)],
+        location()
+      );
     }
 
 // Template documents can contain backticks at the top level.
 templateDocumentChar
   = !("${") @textChar
 
-// The contents of a template document containing plain text and substitutions
-templateDocumentContents
-  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
-      return annotate(makeTemplate(ops.template, head, tail), location());
-    }
-
 templateDocumentText "template text"
   = chars:templateDocumentChar* {
       return chars.join("");
@@ -592,17 +589,13 @@ templateDocumentText "template text"
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
-  = "`" contents:templateLiteralContents "`" {
-      return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
+  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* "`" {
+      return annotate(makeTemplate(ops.template, head, tail), location());
     }
 
 templateLiteralChar
   = !("`" / "${") @textChar
 
-// The contents of a template literal containing plain text and substitutions
-templateLiteralContents
-  = head:templateLiteralText tail:(templateSubstitution templateLiteralText)*
-
 // Plain text in a template literal
 templateLiteralText
   = chars:templateLiteralChar* {
@@ -632,5 +625,10 @@ unaryOperator
   / "-"
   / "~"
 
+whitespace
+  = inlineSpace
+  / newLine
+  / comment
+
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __