@weborigami/language 0.6.10 → 0.6.12

package/main.js

@@ -13,11 +13,9 @@ export { default as projectRoot } from "./src/project/projectRoot.js";
 export { default as projectRootFromPath } from "./src/project/projectRootFromPath.js";
 export * as Protocols from "./src/protocols/protocols.js";
 export { formatError, highlightError, lineInfo } from "./src/runtime/errors.js";
+export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
-export {
-  default as evaluate,
-  default as execute,
-} from "./src/runtime/execute.js";
+export { default as execute } from "./src/runtime/execute.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
 export { default as expressionObject } from "./src/runtime/expressionObject.js";
 export * from "./src/runtime/handleExtension.js";

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "24.10.1",
+    "@types/node": "25.3.2",
     "peggy": "5.0.6",
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.10",
+    "@weborigami/async-tree": "0.6.12",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
-    "yaml": "2.8.1"
+    "yaml": "2.8.2"
   },
   "scripts": {
     "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",

package/src/compiler/origami.pegjs

@@ -845,8 +845,10 @@ relationalExpression
   // We disallow a newline before the relational operator to support a newline
   // as a separator in an object literal that has an object shorthand property
   // with an angle bracket path. Otherwise the opening angle bracket would be
-  // interpreted as a relational operator.
-  = head:shiftExpression tail:(inlineSpace @relationalOperator __ @shiftExpression)* {
+  // interpreted as a relational operator. In shell mode we require a space to
+  // avoid ambiguity with an angle bracket literal as an argument in an implicit
+  // parentheses call.
+  = head:shiftExpression tail:(inlineSpace @relationalOperator whitespaceRequiredForShell @shiftExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -1039,9 +1041,9 @@ uriKey
 
 // A single character in a URI key
 uriKeyChar
-  // Accept anything that doesn't end the URI key or path
-  // Reject whitespace; see notes for `whitespace` term
-  = char:[^/,\)\]\}] !&{ return /\s/.test(char); } { return char; }
+  // Accept anything except whitespace (see notes for `whitespace` term),
+  // brackets, comma, or slash
+  = char:[^/,\(\[\{\)\]\}] !&{ return /\s/.test(char); } { return char; }
   / escapedChar
 
 // A slash-separated path of keys: `a/b/c`
@@ -1071,6 +1073,10 @@ whitespaceOptionalForProgram
   = programMode __
   / shellMode
 
+whitespaceRequiredForShell
+  = shellMode whitespace
+  / programMode __
+
 whitespaceOrParenthesis
   = whitespace
   / "("

package/src/compiler/parse.js

@@ -357,6 +357,7 @@ function peg$parse(input, options) {
     whitespace: peg$parsewhitespace,
     whitespaceChar: peg$parsewhitespaceChar,
     whitespaceOptionalForProgram: peg$parsewhitespaceOptionalForProgram,
+    whitespaceRequiredForShell: peg$parsewhitespaceRequiredForShell,
     whitespaceOrParenthesis: peg$parsewhitespaceOrParenthesis,
     whitespaceWithNewLine: peg$parsewhitespaceWithNewLine,
   };
@@ -459,7 +460,7 @@ function peg$parse(input, options) {
   const peg$r19 = /^[^\n\r]/;
   const peg$r20 = /^[!+]/;
   const peg$r21 = /^[\/)\]}]/;
-  const peg$r22 = /^[^\/,)\]}]/;
+  const peg$r22 = /^[^\/,([{)\]}]/;
   const peg$r23 = /^[a-z]/;
   const peg$r24 = /^[a-z0-9+-.]/;
   const peg$r25 = /^[:]/;
@@ -589,7 +590,7 @@ function peg$parse(input, options) {
   const peg$e122 = peg$literalExpectation("await", false);
   const peg$e123 = peg$literalExpectation("typeof", false);
   const peg$e124 = peg$literalExpectation("void", false);
-  const peg$e125 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false, false);
+  const peg$e125 = peg$classExpectation(["/", ",", "(", "[", "{", ")", "]", "}"], true, false, false);
   const peg$e126 = peg$otherExpectation("slash-separated path");
   const peg$e127 = peg$classExpectation([["a", "z"]], false, false, false);
   const peg$e128 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false, false);
@@ -6313,10 +6314,15 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         s5 = peg$parserelationalOperator();
         if (s5 !== peg$FAILED) {
-          s6 = peg$parse__();
-          s7 = peg$parseshiftExpression();
-          if (s7 !== peg$FAILED) {
-            s3 = [ s5, s7 ];
+          s6 = peg$parsewhitespaceRequiredForShell();
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parseshiftExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = [ s5, s7 ];
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -6336,10 +6342,15 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parserelationalOperator();
           if (s5 !== peg$FAILED) {
-            s6 = peg$parse__();
-            s7 = peg$parseshiftExpression();
-            if (s7 !== peg$FAILED) {
-              s3 = [ s5, s7 ];
+            s6 = peg$parsewhitespaceRequiredForShell();
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parseshiftExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = [ s5, s7 ];
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -7834,6 +7845,40 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parsewhitespaceRequiredForShell() {
+    let s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseshellMode();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parsewhitespace();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseprogramMode();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
   function peg$parsewhitespaceOrParenthesis() {
     let s0;
 
@@ -8075,6 +8120,7 @@ const peg$allowedStartRules = [
   "whitespace",
   "whitespaceChar",
   "whitespaceOptionalForProgram",
+  "whitespaceRequiredForShell",
   "whitespaceOrParenthesis",
   "whitespaceWithNewLine"
 ];

package/src/compiler/parserHelpers.js

@@ -634,8 +634,7 @@ function makePossibleSpreadCall(target, args, location) {
     return [target, ...args];
   }
 
-  // Get function's apply method
-  const applyMethod = annotate([ops.property, target, "apply"], location);
+  // We'll need to use ops.apply and ops.flat to handle the spreads.
   const wrappedArgs = args.map((arg) => {
     if (arg[0] === markers.spread) {
       return arg[1];
@@ -643,8 +642,8 @@ function makePossibleSpreadCall(target, args, location) {
       return annotate([ops.array, arg], arg.location);
     }
   });
-  const flatCall = annotate([ops.flat, ...wrappedArgs], location);
-  return [applyMethod, null, flatCall];
+  const flattened = annotate([ops.flat, ...wrappedArgs], location);
+  return annotate([ops.apply, target, flattened], location);
 }
 
 /**

package/src/handlers/sh_handler.js

@@ -26,10 +26,15 @@ export default {
  * Supports multiple commands, pipelines, redirects, etc.
  *
  * @param {string} scriptText - Shell code (may contain newlines/side effects)
- * @param {string} inputText  - Text to pipe to the script's stdin
+ * @param {import("@weborigami/async-tree").Stringlike} inputText  - Text to pipe to the script's stdin
  * @returns {Promise<string>}
  */
 function runShellScript(scriptText, inputText) {
+  if (inputText instanceof Function) {
+    throw new Error(
+      "A .sh file expects text input but got a function instead. Did you mean to invoke the function?",
+    );
+  }
   return new Promise((resolve, reject) => {
     // Use sh -c "<scriptText>" so stdin is free for inputText
     const child = spawn("sh", ["-c", scriptText], {
@@ -49,7 +54,7 @@ function runShellScript(scriptText, inputText) {
       if (code !== 0) {
         /** @type {any} */
         const err = new Error(
-          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`
+          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`,
         );
         err.code = code;
         err.stdout = stdout;

package/src/handlers/yaml_handler.js

@@ -1,4 +1,5 @@
 import {
+  castArraylike,
   getParent,
   isUnpackable,
   symbols,
@@ -82,8 +83,13 @@ export default {
     }
 
     if (hasOriTags) {
-      // Resolve any promises in the data.
-      data = await Tree.plain(data);
+      // Invoke any functions and resolve any promises in the deep data.
+      const tree = Tree.from(data, { deep: true });
+      data = await Tree.mapReduce(
+        tree,
+        async (value) => (value instanceof Function ? await value() : value),
+        (mapped) => castArraylike(mapped),
+      );
     }
 
     if (data && typeof data === "object" && Object.isExtensible(data)) {

package/src/project/jsGlobals.js

@@ -128,7 +128,7 @@ const globals = {
   encodeURIComponent,
   escape,
   eval,
-  // fetch -- special case, see below
+  fetch,
   globalThis,
   isFinite,
   isNaN,
@@ -150,7 +150,6 @@ const globals = {
   true: true,
 
   // Special cases
-  fetch: fetchWrapper,
   import: importWrapper,
 };
 
@@ -160,14 +159,6 @@ Object.defineProperty(globals, "globalThis", {
   value: globals,
 });
 
-async function fetchWrapper(resource, options) {
-  console.warn(
-    "Warning: A plain `fetch` reference will eventually call the standard JavaScript fetch() function. For Origami's fetch behavior, update your code to call Origami.fetch().",
-  );
-  const response = await fetch(resource, options);
-  return response.ok ? await response.arrayBuffer() : undefined;
-}
-
 /**
  * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
  *

package/src/protocols/package.js

@@ -1,4 +1,4 @@
-import { Tree, keysFromPath } from "@weborigami/async-tree";
+import { Tree, keysFromPath, pathFromKeys } from "@weborigami/async-tree";
 import projectRoot from "../project/projectRoot.js";
 
 /**
@@ -11,27 +11,36 @@ export default async function packageProtocol(...args) {
   const root = await projectRoot(state);
 
   // Identify the path to the package root
-  const packageRootPath = ["node_modules"];
-  const name = args.shift();
-  packageRootPath.push(name);
+  const packageRootKeys = ["node_modules"];
+  let name = args.shift();
+  packageRootKeys.push(name);
   if (name.startsWith("@")) {
     // First key is an npm organization, add next key as name
-    packageRootPath.push(args.shift());
+    const nameArg = args.shift();
+    name += nameArg;
+    packageRootKeys.push(nameArg);
   }
+  const packageRootPath = pathFromKeys(packageRootKeys);
 
   // Get the package root (top level folder of the package)
-  const packageRoot = await Tree.traverse(root, ...packageRootPath);
+  let packageRoot = await Tree.traverse(root, ...packageRootKeys);
   if (!packageRoot) {
-    throw new Error(`Can't find ${packageRootPath.join("/")}`);
+    // Can't find package -- are we *in* the package?
+    const packageJson = await Tree.traverse(root, "package.json");
+    const packageData = await packageJson?.unpack();
+    if (packageData?.name === name) {
+      // Yes, we're in the package itself
+      packageRoot = root;
+    } else {
+      throw new Error(`Can't find ${packageRootPath}`);
+    }
   }
 
   // Identify the main entry point
   const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
   if (mainPath === undefined) {
     throw new Error(
-      `${packageRootPath.join(
-        "/",
-      )} doesn't contain a package.json with a "main" entry.`,
+      `${packageRootPath} doesn't contain a package.json with a "main" entry.`,
     );
   }
 

package/src/runtime/WatchFilesMixin.d.ts

@@ -1,5 +1,7 @@
 import { Mixin } from "../../index.ts";
 
-declare const WatchFilesMixin: Mixin<{}>;
+declare const WatchFilesMixin: Mixin<{
+  watch(): Promise<void>;
+}>;
 
 export default WatchFilesMixin;

package/src/runtime/WatchFilesMixin.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import path from "node:path";
 import Watcher from "watcher";
 import TreeEvent from "./TreeEvent.js";
 
@@ -17,6 +18,12 @@ export default function WatchFilesMixin(Base) {
     onChange(filePath) {
       // Reset cached values.
       this.subfoldersMap = new Map();
+
+      // Special case: ignore events in .git folder
+      if (filePath.includes(`${path.sep}.git${path.sep}`)) {
+        return;
+      }
+
       this.dispatchEvent(new TreeEvent("change", { filePath }));
     }
 

package/src/runtime/errors.js

@@ -20,6 +20,11 @@ const origamiSourceSignals = [
  * @param {Error} error
  */
 export async function formatError(error) {
+  // We want to display information for the root cause
+  while (error.cause instanceof Error) {
+    error = error.cause;
+  }
+
   // Get the original error message
   let originalMessage;
   // If the first line of the stack is just the error message, use that as the message

package/src/runtime/execute.js

@@ -19,23 +19,13 @@ export default async function execute(code, state = {}) {
     return code;
   }
 
-  let evaluated;
-  if (code[0]?.unevaluatedArgs) {
-    // Don't evaluate instructions, use as is.
-    evaluated = code;
-  } else {
-    // Evaluate each instruction in the code.
-    evaluated = await Promise.all(
-      code.map((instruction) => execute(instruction, state)),
-    );
-  }
-
   // Add the code to the runtime state
   /** @type {import("../../index.ts").CodeContext} */
   const context = { state, code };
 
-  // The head of the array is a function or a map; the rest are args or keys.
-  let [fn, ...args] = evaluated;
+  // Start by evaluating the head of the instruction
+  const [head, ...tail] = code;
+  let fn = await execute(head, state);
 
   if (!fn) {
     // The code wants to invoke something that's couldn't be found in scope.
@@ -53,9 +43,23 @@ export default async function execute(code, state = {}) {
     fn = await fn.unpack();
   }
 
+  let args;
+  if (fn?.unevaluatedArgs) {
+    // Don't evaluate instructions, use as is.
+    args = tail;
+  } else {
+    // Evaluate each instruction in the code.
+    args = await Promise.all(
+      tail.map((instruction) => execute(instruction, state)),
+    );
+  }
+
   if (fn.needsState) {
     // The function is an op that wants the runtime state
     args.push(state);
+  } else if (fn.needsContext) {
+    // The function is an op that wants the code context
+    args.push(context);
   } else if (fn.parentAsTarget && state.parent) {
     // The function wants the code's parent as the `this` target
     fn = fn.bind(state.parent);

package/src/runtime/ops.js

@@ -26,6 +26,28 @@ export function addition(a, b) {
 }
 addOpLabel(addition, "«ops.addition»");
 
+/**
+ * Flatten the arguments and then apply the function.
+ * This is used to handle spreads in function calls.
+ */
+export async function apply(fn, args, state) {
+  // TODO: This is starting to recapitulate much of execute()
+  if (isUnpackable(fn)) {
+    fn = await fn.unpack();
+  }
+  if (fn.needsState) {
+    // The function is an op that wants the runtime state
+    args.push(state);
+  }
+  const result =
+    fn instanceof Function
+      ? await fn(...args) // Invoke the function
+      : await Tree.traverseOrThrow(fn, ...args); // Traverse the map.
+  return result;
+}
+addOpLabel(apply, "«ops.apply»");
+apply.needsState = true;
+
 /**
  * Construct an array.
  *
@@ -157,11 +179,14 @@ addOpLabel(exponentiation, "«ops.exponentiation»");
  */
 export async function flat(...args) {
   const arrays = await Promise.all(
-    args.map(async (arg) =>
-      arg instanceof Array || typeof arg !== "object"
+    args.map(async (arg) => {
+      if (isUnpackable(arg)) {
+        arg = await arg.unpack();
+      }
+      return arg instanceof Array || typeof arg !== "object"
         ? arg
-        : await Tree.values(arg),
-    ),
+        : await Tree.values(arg);
+    }),
   );
 
   return arrays.flat();

package/test/compiler/parse.test.js

@@ -569,8 +569,8 @@ describe("Origami parser", () => {
 
     test("parentheses arguments with spreads", () => {
       assertParse("callExpression", "fn(a, ...b, ...c)", [
-        [ops.property, [markers.traverse, [markers.reference, "fn"]], "apply"],
-        null,
+        ops.apply,
+        [markers.traverse, [markers.reference, "fn"]],
         [
           ops.flat,
           [ops.array, [markers.traverse, [markers.reference, "a"]]],
@@ -1126,12 +1126,8 @@ Body`,
       "implicitParenthesesCallExpression",
       "concat a.json, ...b.json, c.json",
       [
-        [
-          ops.property,
-          [markers.traverse, [markers.reference, "concat"]],
-          "apply",
-        ],
-        null,
+        ops.apply,
+        [markers.traverse, [markers.reference, "concat"]],
         [
           ops.flat,
           [ops.array, [markers.traverse, [markers.reference, "a.json"]]],

package/test/runtime/ops.test.js

@@ -20,6 +20,12 @@ describe("ops", () => {
     );
   });
 
+  test("ops.apply applies a function to arguments", async () => {
+    const code = createCode([ops.apply, ops.addition, [ops.array, 1, 2]]);
+    const result = await execute(code);
+    assert.strictEqual(result, 3);
+  });
+
   test("ops.array creates an array", async () => {
     const code = createCode([ops.array, 1, 2, 3]);
     const result = await execute(code);