@weborigami/language 0.6.10 → 0.6.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.10",
+    "@weborigami/async-tree": "0.6.11",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

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/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/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

@@ -56,6 +56,9 @@ export default async function execute(code, 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);