@weborigami/language 0.5.1 → 0.5.2

package/index.ts

@@ -1,4 +1,4 @@
-import { Packed } from "@weborigami/async-tree";
+import { UnpackFunction } from "@weborigami/async-tree";
 
 export * from "./main.js";
 
@@ -64,8 +64,3 @@ export type Source = {
   text: string;
   url?: URL;
 }
-
-/**
- * A function that converts a value from a persistent form into a live value.
- */
-export type UnpackFunction = (input: Packed, options?: any) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.1",
-    "@weborigami/types": "0.5.1",
+    "@weborigami/async-tree": "0.5.2",
+    "@weborigami/types": "0.5.2",
     "watcher": "2.3.1",
     "yaml": "2.8.1"
   },

package/src/compiler/origami.pegjs

@@ -549,23 +549,24 @@ objectProperty "object property"
 
 // A shorthand reference inside an object literal: `foo`
 objectShorthandProperty "object identifier"
-  = key:objectPublicKey {
-      const reference = annotate([markers.reference, key], location());
-      const traverse = annotate([markers.traverse, reference], location());
-      return annotate([key, traverse], location());
+  = path:pathLiteral {
+      const lastKey = path[0] === ops.unpack
+        // [ops.unpack, [markers.traverse, [markers.reference, lastKey]]]
+        ? path[1][1][1]
+        // [markers.traverse, ..., [markers.reference, lastKey]
+        : path.at(-1)[1];
+      return annotate([lastKey, path], location());
     }
   / path:angleBracketLiteral {
-    let lastKey = path.at(-1);
-    if (lastKey instanceof Array) {
-      lastKey = lastKey[1]; // get scope identifier or literal
+      // [markers.traverse, ..., [markers.reference, lastKey]]
+      const lastKey = path.at(-1)[1];
+      return annotate([lastKey, path], location());
     }
-    return annotate([lastKey, path], location());
-  }
 
 objectPublicKey
   = key:key slash:"/"? {
-    return text();
-  }
+      return text();
+    }
   / string:stringLiteral {
       // Remove `ops.literal` from the string code
       return string[1];
@@ -573,8 +574,8 @@ objectPublicKey
 
 optionalChaining
   = __ "?." __ property:identifier {
-    return annotate([ops.optionalTraverse, property], location());
-  }
+      return annotate([ops.optionalTraverse, property], location());
+    }
 
 // Name of a unction parameter
 parameter

package/src/compiler/parse.js

@@ -761,16 +761,17 @@ function peg$parse(input, options) {
   function peg$f69(key, pipeline) {
     return annotate([key, pipeline], location());
   }
-  function peg$f70(key) {
-    const reference = annotate([markers.reference, key], location());
-    const traverse = annotate([markers.traverse, reference], location());
-    return annotate([key, traverse], location());
+  function peg$f70(path) {
+    const lastKey = path[0] === ops.unpack
+      // [ops.unpack, [markers.traverse, [markers.reference, lastKey]]]
+      ? path[1][1][1]
+      // [markers.traverse, ..., [markers.reference, lastKey]
+      : path.at(-1)[1];
+    return annotate([lastKey, path], location());
   }
   function peg$f71(path) {
-    let lastKey = path.at(-1);
-    if (lastKey instanceof Array) {
-      lastKey = lastKey[1]; // get scope identifier or literal
-    }
+    // [markers.traverse, ..., [markers.reference, lastKey]]
+    const lastKey = path.at(-1)[1];
     return annotate([lastKey, path], location());
   }
   function peg$f72(key, slash) {
@@ -4539,7 +4540,7 @@ function peg$parse(input, options) {
 
     peg$silentFails++;
     s0 = peg$currPos;
-    s1 = peg$parseobjectPublicKey();
+    s1 = peg$parsepathLiteral();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
       s1 = peg$f70(s1);

package/src/runtime/HandleExtensionsTransform.js

@@ -4,7 +4,7 @@ import { handleExtension } from "./handlers.js";
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
- * @typedef {import("../../index.ts").UnpackFunction} FileUnpackFunction
+ * @typedef {import("@weborigami/async-tree").UnpackFunction} FileUnpackFunction
  *
  * @param {AsyncTreeConstructor} Base
  */

package/src/runtime/jsGlobals.js

@@ -12,7 +12,7 @@ import path from "node:path";
  * Fetch API
  * URL API
  */
-const globals = {
+const globals = bindStaticMethodsForGlobals({
   AbortController,
   AbortSignal,
   AggregateError,
@@ -152,7 +152,7 @@ const globals = {
   // Special cases
   fetch: fetchWrapper,
   import: importWrapper,
-};
+});
 
 // Give access to our own custom globals as `globalThis`
 Object.defineProperty(globals, "globalThis", {
@@ -160,8 +160,6 @@ Object.defineProperty(globals, "globalThis", {
   value: globals,
 });
 
-export default 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()."
@@ -186,3 +184,60 @@ async function importWrapper(modulePath) {
   const filePath = path.resolve(current.path, modulePath);
   return import(filePath);
 }
+
+/**
+ * Some JavaScript globals like Promise have static methods like Promise.all
+ * verify that the call target is the class. This creates an issue because the
+ * Origami evaluate() function calls all functions with the evaluation context
+ * -- the tree in which the code is running -- as the call target.
+ *
+ * This function works around the problem. If the indicated classFn has no
+ * static methods, it's returned as is. If it does have static methods, this
+ * returns an extension of the classFn prototype that overrides the static
+ * methods with ones that are bound to the class.
+ */
+function bindStaticMethodsForClass(fn) {
+  const staticMethodDescriptors = Object.entries(
+    Object.getOwnPropertyDescriptors(fn)
+  )
+    .filter(([key, descriptor]) => descriptor.value instanceof Function)
+    .map(([key, descriptor]) => [
+      key,
+      {
+        ...descriptor,
+        value: descriptor.value.bind(fn),
+      },
+    ]);
+  if (staticMethodDescriptors.length === 0) {
+    // No static methods
+    return fn;
+  }
+
+  let extended;
+  if (!fn.prototype) {
+    // A function like Proxy
+    extended = Object.create(fn);
+  } else {
+    /** @this {any} */
+    extended = function (...args) {
+      const calledWithNew = this instanceof extended;
+      return calledWithNew ? new fn(...args) : fn(...args);
+    };
+  }
+
+  return Object.defineProperties(
+    extended,
+    Object.fromEntries(staticMethodDescriptors)
+  );
+}
+
+function bindStaticMethodsForGlobals(objects) {
+  const entries = Object.entries(objects);
+  const bound = entries.map(([key, value]) => [
+    key,
+    value instanceof Function ? bindStaticMethodsForClass(value) : value,
+  ]);
+  return Object.fromEntries(bound);
+}
+
+export default globals;

package/test/compiler/parse.test.js

@@ -1019,44 +1019,66 @@ Body`,
     });
   });
 
-  test("objectEntry", () => {
-    assertParse("objectEntry", "foo", [
-      "foo",
-      [markers.traverse, [markers.reference, "foo"]],
-    ]);
-    assertParse("objectEntry", "index.html: x", [
-      "index.html",
-      [markers.traverse, [markers.reference, "x"]],
-    ]);
-    assertParse("objectEntry", "a: a", [
-      "a",
-      [markers.traverse, [markers.reference, "a"]],
-    ]);
-    assertParse("objectEntry", "<path/to/file.txt>", [
-      "file.txt",
-      [
-        markers.traverse,
-        [markers.external, "path/"],
-        [ops.literal, "to/"],
-        [ops.literal, "file.txt"],
-      ],
-    ]);
-    assertParse("objectEntry", "a: (a) => a", [
-      "a",
-      [
-        ops.lambda,
-        [[ops.literal, "a"]],
+  describe("objectEntry", () => {
+    test("shorthand", () => {
+      assertParse("objectEntry", "foo", [
+        "foo",
+        [markers.traverse, [markers.reference, "foo"]],
+      ]);
+      assertParse("objectEntry", "folder/", [
+        "folder/",
+        [ops.unpack, [markers.traverse, [markers.reference, "folder/"]]],
+      ]);
+      assertParse("objectEntry", "path/to/file.txt", [
+        "file.txt",
+        [
+          markers.traverse,
+          [markers.reference, "path/"],
+          [ops.literal, "to/"],
+          [ops.literal, "file.txt"],
+        ],
+      ]);
+      assertParse("objectEntry", "<folder/>", [
+        "folder/",
+        [markers.traverse, [markers.external, "folder/"]],
+      ]);
+      assertParse("objectEntry", "<path/to/file.txt>", [
+        "file.txt",
+        [
+          markers.traverse,
+          [markers.external, "path/"],
+          [ops.literal, "to/"],
+          [ops.literal, "file.txt"],
+        ],
+      ]);
+    });
+
+    test("key: value", () => {
+      assertParse("objectEntry", "index.html: x", [
+        "index.html",
+        [markers.traverse, [markers.reference, "x"]],
+      ]);
+      assertParse("objectEntry", "a: a", [
+        "a",
         [markers.traverse, [markers.reference, "a"]],
-      ],
-    ]);
-    assertParse("objectEntry", "posts/: map(posts, post.ori)", [
-      "posts/",
-      [
-        [markers.traverse, [markers.reference, "map"]],
-        [markers.traverse, [markers.reference, "posts"]],
-        [markers.traverse, [markers.reference, "post.ori"]],
-      ],
-    ]);
+      ]);
+      assertParse("objectEntry", "a: (a) => a", [
+        "a",
+        [
+          ops.lambda,
+          [[ops.literal, "a"]],
+          [markers.traverse, [markers.reference, "a"]],
+        ],
+      ]);
+      assertParse("objectEntry", "posts/: map(posts, post.ori)", [
+        "posts/",
+        [
+          [markers.traverse, [markers.reference, "map"]],
+          [markers.traverse, [markers.reference, "posts"]],
+          [markers.traverse, [markers.reference, "post.ori"]],
+        ],
+      ]);
+    });
   });
 
   test("objectGetter", () => {

package/test/runtime/jsGlobals.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import jsGlobals from "../../src/runtime/jsGlobals.js";
+
+describe("jsGlobals", () => {
+  test("wraps static methods to drop the call target", async () => {
+    const { Promise: fixture } = jsGlobals;
+    const target = {};
+    const promise = fixture.resolve.call(target, "hi");
+    const value = await promise;
+    assert.equal(value, "hi");
+  });
+
+  test("can invoke a global constructor", async () => {
+    const { Number: fixture } = jsGlobals;
+    // Without `new`
+    const instance1 = fixture(5);
+    assert.equal(instance1, 5);
+    // With `new`
+    const instance = new fixture();
+    assert(instance instanceof Number);
+  });
+});