@weborigami/language 0.0.42 → 0.0.44

package/src/runtime/FileLoadersTransform.js

@@ -1,6 +1,7 @@
 import { Tree, isStringLike } from "@weborigami/async-tree";
 import Scope from "./Scope.js";
 import extname from "./extname.js";
+import * as symbols from "./symbols.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -14,25 +15,31 @@ export default function FileLoadersTransform(Base) {
     async get(key) {
       let value = await super.get(key);
 
-      // If the value is string-like and the key has an extension, look for a
-      // loader that handles that extension and call it. The value will
-      // typically be a Buffer loaded from the file system, but could also be a
-      // string-like object defined by a user function.
-      if (isStringLike(value) && isStringLike(key)) {
+      // If the key is string-like and has an extension, look for a loader that
+      // handles that extension.
+      if (value && isStringLike(key)) {
         const extension = extname(String(key)).toLowerCase().slice(1);
         if (extension) {
           /** @type {any} */
           const scope = Scope.getScope(this);
-          /** @type {FileUnpackFunction} */
-          const unpackFn = await Tree.traverse(scope, "@loaders", extension);
-          if (unpackFn) {
+          const loader = await Tree.traverse(scope, "@loaders", extension);
+          if (loader) {
             const input = value;
             // If the input is a plain string, convert it to a String so we can
             // attach data to it.
-            value = new String(input);
+            if (typeof input === "string") {
+              value = new String(input);
+            }
             const parent = this;
-            value.parent = parent;
-            value.unpack = unpackFn.bind(null, input, { key, parent });
+            value[symbols.parent] = parent;
+
+            // Wrap the loader with a function that will only be called once per
+            // value.
+            let loaded;
+            value.unpack = async () => {
+              loaded ??= await loader(input, { key, parent });
+              return loaded;
+            };
           }
         }
       }

package/src/runtime/evaluate.js

@@ -81,9 +81,13 @@ export default async function evaluate(code) {
     Object.isExtensible(result) &&
     !isPlainObject(result)
   ) {
-    result[codeSymbol] = code;
-    if (/** @type {any} */ (code).location) {
-      result[sourceSymbol] = codeFragment(code);
+    try {
+      result[codeSymbol] = code;
+      if (/** @type {any} */ (code).location) {
+        result[sourceSymbol] = codeFragment(code);
+      }
+    } catch (/** @type {any} */ error) {
+      // Ignore errors.
     }
   }
 

package/src/runtime/symbols.js

@@ -0,0 +1 @@
+export const parent = Symbol("parent");

package/test/compiler/compile.test.js

@@ -49,7 +49,7 @@ describe("compile", () => {
   });
 
   test("templateLiteral", async () => {
-    await assertCompile("`Hello, {{name}}!`", "Hello, Alice!");
+    await assertCompile("`Hello, ${name}!`", "Hello, Alice!");
     await assertCompile(
       "`escape characters with \\`backslash\\``",
       "escape characters with `backslash`"

package/test/compiler/parse.test.js

@@ -70,7 +70,7 @@ describe("Origami parser", () => {
       ],
       [[ops.scope, "files"], "snapshot"],
     ]);
-    assertParse("expr", "@map =`<li>{{_}}</li>`", [
+    assertParse("expr", "@map =`<li>${_}</li>`", [
       [ops.scope, "@map"],
       [ops.lambda, null, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
     ]);
@@ -109,6 +109,18 @@ describe("Origami parser", () => {
         ],
       ]
     );
+
+    // Consecutive slahes inside a path = empty string key
+    assertParse("expression", "path//key", [
+      ops.traverse,
+      [ops.scope, "path"],
+      "",
+      "key",
+    ]);
+    // Single slash at start of something = absolute file path
+    assertParse("expression", "/path", [[ops.filesRoot], "path"]);
+    // Consecutive slashes at start of something = comment
+    assertParse("expression", "path //comment", [ops.scope, "path"]);
   });
 
   test("functionComposition", () => {
@@ -237,7 +249,7 @@ describe("Origami parser", () => {
       null,
       [ops.scope, "message"],
     ]);
-    assertParse("lambda", "=`Hello, {{name}}.`", [
+    assertParse("lambda", "=`Hello, ${name}.`", [
       ops.lambda,
       null,
       [ops.concat, "Hello, ", [ops.scope, "name"], "."],
@@ -257,6 +269,10 @@ describe("Origami parser", () => {
     assertParse("list", "'a' , 'b' , 'c'", ["a", "b", "c"]);
   });
 
+  test("multiLineComment", () => {
+    assertParse("multiLineComment", "/*\nHello, world!\n*/", null);
+  });
+
   test("number", () => {
     assertParse("number", "123", 123);
     assertParse("number", "-456", -456);
@@ -369,6 +385,14 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("singleLineComment", () => {
+    assertParse("singleLineComment", "# Hello, world!", null);
+  });
+
+  test("singleLineComment (JS)", () => {
+    assertParse("singleLineComment", "// Hello, world!", null);
+  });
+
   test("scopeReference", () => {
     assertParse("scopeReference", "x", [ops.scope, "x"]);
   });
@@ -383,7 +407,7 @@ describe("Origami parser", () => {
   });
 
   test("templateDocument", () => {
-    assertParse("templateDocument", "hello{{foo}}world", [
+    assertParse("templateDocument", "hello${foo}world", [
       ops.lambda,
       null,
       [ops.concat, "hello", [ops.scope, "foo"], "world"],
@@ -414,10 +438,33 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("templateLiteral (JS)", () => {
+    assertParse("templateLiteral", "`Hello, world.`", "Hello, world.");
+    assertParse("templateLiteral", "`foo ${x} bar`", [
+      ops.concat,
+      "foo ",
+      [ops.scope, "x"],
+      " bar",
+    ]);
+    assertParse("templateLiteral", "`${`nested`}`", "nested");
+    assertParse("templateLiteral", "`${map(people, =`${name}`)}`", [
+      ops.concat,
+      [
+        [ops.scope, "map"],
+        [ops.scope, "people"],
+        [ops.lambda, null, [ops.concat, [ops.scope, "name"]]],
+      ],
+    ]);
+  });
+
   test("templateSubstitution", () => {
     assertParse("templateSubstitution", "{{foo}}", [ops.scope, "foo"]);
   });
 
+  test("templateSubtitution (JS)", () => {
+    assertParse("templateSubstitution", "${foo}", [ops.scope, "foo"]);
+  });
+
   test("tree", () => {
     assertParse("tree", "{}", [ops.tree]);
     assertParse("tree", "{ a = 1, b }", [

package/test/runtime/FileLoadersTransform.test.js

@@ -33,7 +33,7 @@ function createFixture() {
   /** @type {any} */
   const scope = {
     "@loaders": {
-      json: (input) => JSON.parse(input),
+      json: (buffer) => JSON.parse(String(buffer)),
     },
   };
   tree = Scope.treeWithScope(tree, scope);