@weborigami/language 0.2.8 → 0.2.10

package/src/compiler/parserHelpers.js

@@ -50,7 +50,10 @@ function avoidRecursivePropertyCalls(code, key) {
   ) {
     // Rewrite to avoid recursion
     modified = [ops.inherited, code[1]];
-  } else if (code[0] === ops.lambda && code[1].includes(key)) {
+  } else if (
+    code[0] === ops.lambda &&
+    code[1].some((param) => param[1] === key)
+  ) {
     // Lambda that defines the key; don't rewrite
     return code;
   } else {

package/src/runtime/EventTargetMixin.d.ts

@@ -1,9 +1,5 @@
 import { Mixin } from "../../index.ts";
 
-declare const EventTargetMixin: Mixin<{
-  addEventListener(type: string, listener: EventListener): void;
-  dispatchEvent(event: Event): boolean;
-  removeEventListener(type: string, listener: EventListener): void;
-}>;
+declare const EventTargetMixin: Mixin<EventTarget>;
 
 export default EventTargetMixin;

package/src/runtime/ops.js

@@ -223,7 +223,8 @@ export function lambda(parameters, code) {
       // Add arguments to scope.
       const ambients = {};
       for (const parameter of parameters) {
-        ambients[parameter] = args.shift();
+        const parameterName = parameter[1];
+        ambients[parameterName] = args.shift();
       }
       Object.defineProperty(ambients, codeSymbol, {
         value: code,

package/test/compiler/optimize.test.js

@@ -18,7 +18,7 @@ describe("optimize", () => {
     const code = fn.code;
     assertCodeEqual(code, [
       ops.lambda,
-      ["name"],
+      [[ops.literal, "name"]],
       [
         ops.object,
         ["a", 1],

package/test/compiler/parse.test.js

@@ -64,12 +64,16 @@ describe("Origami parser", () => {
     ]);
     assertParse("arrowFunction", "x => y", [
       ops.lambda,
-      ["x"],
+      [[ops.literal, "x"]],
       [ops.scope, "y"],
     ]);
     assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
       ops.lambda,
-      ["a", "b", "c"],
+      [
+        [ops.literal, "a"],
+        [ops.literal, "b"],
+        [ops.literal, "c"],
+      ],
       [
         [ops.builtin, "fn"],
         [ops.scope, "a"],
@@ -79,10 +83,10 @@ describe("Origami parser", () => {
     ]);
     assertParse("arrowFunction", "a => b => fn(a, b)", [
       ops.lambda,
-      ["a"],
+      [[ops.literal, "a"]],
       [
         ops.lambda,
-        ["b"],
+        [[ops.literal, "b"]],
         [
           [ops.builtin, "fn"],
           [ops.scope, "a"],
@@ -259,7 +263,7 @@ describe("Origami parser", () => {
     assertParse("conditionalExpression", "false ? =1 : 0", [
       ops.conditional,
       [ops.scope, "false"],
-      [ops.lambda, [], [ops.lambda, ["_"], [ops.literal, "1"]]],
+      [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, "1"]]],
       [ops.literal, "0"],
     ]);
   });
@@ -282,6 +286,18 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("errors for missing pieces", () => {
+    assertThrows("arrowFunction", "(a) => ", "Expected an expression");
+    assertThrows("arrowFunction", "a ⇒ ", "Expected an expression");
+    assertThrows("callExpression", "fn(a", "Expected right parenthesis");
+    assertThrows("doubleQuoteString", '"foo', "Expected closing quote");
+    assertThrows("guillemetString", "«foo", "Expected closing guillemet");
+    assertThrows("objectGetter", "a =", "Expected an expression");
+    assertThrows("objectProperty", "a:", "Expected an expression");
+    assertThrows("singleQuoteString", "'foo", "Expected closing quote");
+    assertThrows("templateLiteral", "`foo", "Expected closing backtick");
+  });
+
   test("exponentiationExpression", () => {
     assertParse("exponentiationExpression", "2 ** 2 ** 3", [
       ops.exponentiation,
@@ -389,7 +405,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expression", "fn =`x`", [
       [ops.builtin, "fn"],
-      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
+      [ops.lambda, [[ops.literal, "_"]], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expression", "copy app.js(formulas), files:snapshot", [
       [ops.builtin, "copy"],
@@ -406,7 +422,7 @@ describe("Origami parser", () => {
       [ops.builtin, "map"],
       [
         ops.lambda,
-        ["_"],
+        [[ops.literal, "_"]],
         [
           ops.template,
           [ops.literal, ["<li>", "</li>"]],
@@ -426,7 +442,10 @@ describe("Origami parser", () => {
     ]);
     assertParse("expression", "(post, slug) => fn.js(post, slug)", [
       ops.lambda,
-      ["post", "slug"],
+      [
+        [ops.literal, "post"],
+        [ops.literal, "slug"],
+      ],
       [
         [ops.scope, "fn.js"],
         [ops.scope, "post"],
@@ -718,7 +737,7 @@ describe("Origami parser", () => {
     assertParse("objectEntry", "a: a", ["a", [ops.inherited, "a"]]);
     assertParse("objectEntry", "a: (a) => a", [
       "a",
-      [ops.lambda, ["a"], [ops.scope, "a"]],
+      [ops.lambda, [[ops.literal, "a"]], [ops.scope, "a"]],
     ]);
     assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
@@ -943,12 +962,12 @@ describe("Origami parser", () => {
   test("shorthandFunction", () => {
     assertParse("shorthandFunction", "=message", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [undetermined, "message"],
     ]);
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.template,
         [ops.literal, ["Hello, ", "."]],
@@ -957,7 +976,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         [ops.builtin, "indent"],
         [ops.literal, ["hello"]],
@@ -991,7 +1010,7 @@ describe("Origami parser", () => {
   test("templateDocument", () => {
     assertParse("templateDocument", "hello${foo}world", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.templateIndent,
         [ops.literal, ["hello", "world"]],
@@ -1000,7 +1019,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.templateIndent,
         [ops.literal, ["Documents can contain ` backticks"]],
@@ -1033,7 +1052,7 @@ describe("Origami parser", () => {
           [ops.scope, "people"],
           [
             ops.lambda,
-            ["_"],
+            [[ops.literal, "_"]],
             [
               ops.template,
               [ops.literal, ["", ""]],
@@ -1101,3 +1120,19 @@ function assertCodeLocations(code) {
     }
   }
 }
+
+function assertThrows(startRule, source, message) {
+  try {
+    parse(source, {
+      grammarSource: { text: source },
+      startRule,
+    });
+  } catch (/** @type {any} */ error) {
+    assert(
+      error.message.includes(message),
+      `Error message incorrect:\n  expected: "${message}"\n  actual: "${error.message}"`
+    );
+    return;
+  }
+  assert.fail(`Expected error: ${message}`);
+}

package/test/runtime/ops.test.js

@@ -169,7 +169,10 @@ describe("ops", () => {
   test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
-      ["a", "b"],
+      [
+        [ops.literal, "a"],
+        [ops.literal, "b"],
+      ],
       [ops.concat, [ops.scope, "b"], [ops.scope, "a"]],
     ]);
     const fn = await evaluate.call(null, code);