@weborigami/language 0.5.2-test.1 → 0.5.3

package/src/compiler/parserHelpers.js

@@ -455,8 +455,12 @@ export function makeUnaryOperation(operator, value, location) {
     "+": ops.unaryPlus,
     "-": ops.unaryMinus,
     "~": ops.bitwiseNot,
+    await: null, // no-op
+    typeof: ops.typeOf,
+    void: ops.voidOp,
   };
-  return annotate([operators[operator], value], location);
+  const op = operators[operator];
+  return op ? annotate([op, value], location) : annotate(value, location);
 }
 
 /**

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,64 @@ 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 object has no static
+ * methods, it's returned as is. If it does have static methods, this returns an
+ * extension of the object that overrides the static methods with ones that are
+ * bound to the object.
+ */
+function bindStaticMethods(obj) {
+  if (typeof obj !== "function" && (typeof obj !== "object" || obj === null)) {
+    // Something like `NaN` or `null`
+    return obj;
+  }
+
+  const staticMethodDescriptors = Object.entries(
+    Object.getOwnPropertyDescriptors(obj)
+  )
+    .filter(([key, descriptor]) => descriptor.value instanceof Function)
+    .map(([key, descriptor]) => [
+      key,
+      {
+        ...descriptor,
+        value: descriptor.value.bind(obj),
+      },
+    ]);
+  if (staticMethodDescriptors.length === 0) {
+    // No static methods
+    return obj;
+  }
+
+  let extended;
+  // A regular object or an oddball like Proxy with no prototype
+  if (typeof obj === "object" || !obj.prototype) {
+    extended = Object.create(obj);
+  } else {
+    /** @this {any} */
+    extended = function (...args) {
+      const calledWithNew = this instanceof extended;
+      return calledWithNew ? new obj(...args) : obj(...args);
+    };
+  }
+
+  Object.defineProperties(
+    extended,
+    Object.fromEntries(staticMethodDescriptors)
+  );
+
+  return extended;
+}
+
+function bindStaticMethodsForGlobals(objects) {
+  const entries = Object.entries(objects);
+  const bound = entries.map(([key, value]) => [key, bindStaticMethods(value)]);
+  return Object.fromEntries(bound);
+}
+
+export default globals;

package/src/runtime/ops.js

@@ -547,6 +547,18 @@ export async function templateText(strings, ...values) {
 }
 addOpLabel(templateText, "«ops.templateText»");
 
+/**
+ * Emulate the JavaScript `typeof` operator
+ *
+ * Note the name is `typeOf` (uppercase "O"), as `typeof` is a reserved word
+ *
+ * @param {any} value
+ */
+export function typeOf(value) {
+  return typeof value;
+}
+addOpLabel(typeOf, "«ops.typeOf»");
+
 export function unaryMinus(a) {
   return -a;
 }
@@ -567,3 +579,13 @@ export async function unpack(value) {
   return isUnpackable(value) ? value.unpack() : value;
 }
 addOpLabel(unpack, "«ops.unpack»");
+
+/**
+ * Emulate JavaScript's rarely-used `void` operator
+ *
+ * @param {any} value
+ */
+export function voidOp(value) {
+  return undefined;
+}
+addOpLabel(voidOp, "«ops.voidOp»");

package/test/compiler/parse.test.js

@@ -155,6 +155,11 @@ describe("Origami parser", () => {
         ],
       ],
     ]);
+    assertParse("arrowFunction", "async (x) => x", [
+      ops.lambda,
+      [[ops.literal, "x"]],
+      [markers.traverse, [markers.reference, "x"]],
+    ]);
   });
 
   test("bitwiseAndExpression", () => {
@@ -1019,44 +1024,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", () => {
@@ -1543,6 +1570,9 @@ Body text`,
     assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
     assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
     assertParse("unaryExpression", "~3", [ops.bitwiseNot, [ops.literal, 3]]);
+    assertParse("unaryExpression", "typeof 1", [ops.typeOf, [ops.literal, 1]]);
+    assertParse("unaryExpression", "void 0", [ops.voidOp, [ops.literal, 0]]);
+    assertParse("unaryExpression", "await 2", [ops.literal, 2]);
   });
 
   test("unaryOperator", () => {

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);
+  });
+});

package/test/runtime/ops.test.js

@@ -414,6 +414,17 @@ describe("ops", () => {
     assert.strictEqual(ops.subtraction(5, true), 4);
   });
 
+  test("ops.typeOf emulates JavaScript typeof", () => {
+    assert.strictEqual(ops.typeOf(true), "boolean");
+    assert.strictEqual(ops.typeOf(1), "number");
+    assert.strictEqual(ops.typeOf("hi"), "string");
+    assert.strictEqual(ops.typeOf(undefined), "undefined");
+    assert.strictEqual(
+      ops.typeOf(() => null),
+      "function"
+    );
+  });
+
   test("ops.unaryMinus", () => {
     assert.strictEqual(ops.unaryMinus(4), -4);
     assert.strictEqual(ops.unaryMinus(-4), 4);
@@ -431,6 +442,12 @@ describe("ops", () => {
     const result = await ops.unpack.call(null, fixture);
     assert.strictEqual(result, "unpacked");
   });
+
+  test("ops.voidOp returns undefined", () => {
+    assert.strictEqual(ops.voidOp(123), undefined);
+    assert.strictEqual(ops.voidOp("hello"), undefined);
+    assert.strictEqual(ops.voidOp(null), undefined);
+  });
 });
 
 function errorFn() {