@weborigami/language 0.0.69 → 0.0.70

package/src/compiler/parserHelpers.js

@@ -153,7 +153,7 @@ export function makeObject(entries, op) {
       value instanceof Array &&
       value[0] === ops.getter &&
       value[1] instanceof Array &&
-      value[1][0] === ops.primitive
+      value[1][0] === ops.literal
     ) {
       // Simplify a getter for a primitive value to a regular property
       value = value[1];
@@ -197,16 +197,12 @@ export function makeProperty(key, value) {
   return [key, modified];
 }
 
-export function makeTemplate(parts) {
-  // Drop empty/null strings.
-  const filtered = parts.filter((part) => part);
-  // Return a concatenation of the parts. If there are no parts, return the
-  // empty string. If there's just one string, return that directly.
-  return filtered.length === 0
-    ? ""
-    : filtered.length === 1 &&
-      filtered[0][0] === ops.primitive &&
-      typeof filtered[0][1] === "string"
-    ? filtered[0]
-    : [ops.concat, ...filtered];
+export function makeTemplate(op, head, tail) {
+  const strings = [head];
+  const values = [];
+  for (const [value, string] of tail) {
+    values.push([ops.concat, value]);
+    strings.push(string);
+  }
+  return [op, [ops.literal, strings], ...values];
 }

package/src/runtime/WatchFilesMixin.js

@@ -43,6 +43,7 @@ export default function WatchFilesMixin(Base) {
       this.watcher = new Watcher(this.dirname, {
         ignoreInitial: true,
         persistent: false,
+        recursive: true,
       });
       this.watcher.on("all", (event, filePath) => {
         const key = path.basename(filePath);

package/src/runtime/evaluate.js

@@ -1,15 +1,7 @@
-import {
-  Tree,
-  isPlainObject,
-  isUnpackable,
-  scope,
-} from "@weborigami/async-tree";
+import { Tree, isUnpackable, scope } from "@weborigami/async-tree";
 import codeFragment from "./codeFragment.js";
 import { ops } from "./internal.js";
-
-const codeSymbol = Symbol("code");
-const scopeSymbol = Symbol("scope");
-const sourceSymbol = Symbol("source");
+import { codeSymbol, scopeSymbol, sourceSymbol } from "./symbols.js";
 
 /**
  * Evaluate the given code and return the result.
@@ -28,7 +20,7 @@ export default async function evaluate(code) {
   }
 
   let evaluated;
-  const unevaluatedFns = [ops.lambda, ops.object];
+  const unevaluatedFns = [ops.lambda, ops.object, ops.literal];
   if (unevaluatedFns.includes(code[0])) {
     // Don't evaluate instructions, use as is.
     evaluated = code;
@@ -93,11 +85,19 @@ export default async function evaluate(code) {
   }
 
   // To aid debugging, add the code to the result.
-  if (Object.isExtensible(result) && !isPlainObject(result)) {
+  if (Object.isExtensible(result) /* && !isPlainObject(result) */) {
     try {
-      result[codeSymbol] = code;
-      if (/** @type {any} */ (code).location) {
-        result[sourceSymbol] = codeFragment(code.location);
+      if (code.location && !result[sourceSymbol]) {
+        Object.defineProperty(result, sourceSymbol, {
+          value: codeFragment(code.location),
+          enumerable: false,
+        });
+      }
+      if (!result[codeSymbol]) {
+        Object.defineProperty(result, codeSymbol, {
+          value: code,
+          enumerable: false,
+        });
       }
       if (!result[scopeSymbol]) {
         Object.defineProperty(result, scopeSymbol, {

package/src/runtime/ops.js

@@ -20,10 +20,18 @@ import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
+import taggedTemplate from "./taggedTemplate.js";
 
 // For memoizing lambda functions
 const lambdaFnMap = new Map();
 
+function addOpLabel(op, label) {
+  Object.defineProperty(op, "toString", {
+    value: () => label,
+    enumerable: false,
+  });
+}
+
 /**
  * Construct an array.
  *
@@ -33,7 +41,7 @@ const lambdaFnMap = new Map();
 export async function array(...items) {
   return Array(...items);
 }
-array.toString = () => "«ops.array»";
+addOpLabel(array, "«ops.array»");
 
 // The assign op is a placeholder for an assignment declaration.
 // It is only used during parsing -- it shouldn't be executed.
@@ -48,7 +56,7 @@ export const assign = "«ops.assign»";
 export async function concat(...args) {
   return treeConcat.call(this, args);
 }
-concat.toString = () => "«ops.concat»";
+addOpLabel(concat, "«ops.concat»");
 
 /**
  * Find the indicated constructor in scope, then return a function which invokes
@@ -71,7 +79,7 @@ export async function constructor(...keys) {
       ? new constructor()
       : new constructor(...args);
 }
-constructor.toString = () => "«ops.constructor»";
+addOpLabel(constructor, "«ops.constructor»");
 
 /**
  * Given a protocol, a host, and a list of keys, construct an href.
@@ -144,6 +152,18 @@ async function fetchResponse(href) {
  */
 export const getter = new String("«ops.getter»");
 
+/**
+ * A site tree with JSON Keys via HTTPS.
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export function explorableSite(host, ...keys) {
+  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
+}
+addOpLabel(explorableSite, "«ops.explorableSite»");
+
 /**
  * Construct a files tree for the filesystem root.
  *
@@ -171,7 +191,7 @@ export async function http(host, ...keys) {
   const href = constructHref("http:", host, ...keys);
   return fetchResponse.call(this, href);
 }
-http.toString = () => "«ops.http»";
+addOpLabel(http, "«ops.http»");
 
 /**
  * Retrieve a web resource via HTTPS.
@@ -184,7 +204,7 @@ export function https(host, ...keys) {
   const href = constructHref("https:", host, ...keys);
   return fetchResponse.call(this, href);
 }
-https.toString = () => "«ops.https»";
+addOpLabel(https, "«ops.https»");
 
 /**
  * Search the parent's scope -- i.e., exclude the current tree -- for the given
@@ -200,7 +220,7 @@ export async function inherited(key) {
   const parentScope = scopeFn(this.parent);
   return parentScope.get(key);
 }
-inherited.toString = () => "«ops.inherited»";
+addOpLabel(inherited, "«ops.inherited»");
 
 /**
  * Return a function that will invoke the given code.
@@ -258,7 +278,15 @@ export function lambda(parameters, code) {
   lambdaFnMap.set(code, invoke);
   return invoke;
 }
-lambda.toString = () => "«ops.lambda";
+addOpLabel(lambda, "«ops.lambda");
+
+/**
+ * Return a primitive value
+ */
+export async function literal(value) {
+  return value;
+}
+addOpLabel(literal, "«ops.literal»");
 
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
@@ -269,7 +297,7 @@ lambda.toString = () => "«ops.lambda";
 export async function merge(...trees) {
   return mergeTrees.call(this, ...trees);
 }
-merge.toString = () => "«ops.merge»";
+addOpLabel(merge, "«ops.merge»");
 
 /**
  * Construct an object. The keys will be the same as the given `obj`
@@ -282,19 +310,7 @@ merge.toString = () => "«ops.merge»";
 export async function object(...entries) {
   return expressionObject(entries, this);
 }
-object.toString = () => "«ops.object»";
-
-/**
- * A site tree with JSON Keys via HTTPS.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export function explorableSite(host, ...keys) {
-  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
-}
-explorableSite.toString = () => "«ops.explorableSite»";
+addOpLabel(object, "«ops.object»");
 
 /**
  * Look up the given key in the scope for the current tree.
@@ -308,7 +324,7 @@ export async function scope(key) {
   const scope = scopeFn(this);
   return scope.get(key);
 }
-scope.toString = () => "«ops.scope»";
+addOpLabel(scope, "«ops.scope»");
 
 /**
  * The spread operator is a placeholder during parsing. It should be replaced
@@ -319,15 +335,15 @@ export function spread(...args) {
     "A compile-time spread operator wasn't converted to an object merge."
   );
 }
-spread.toString = () => "«ops.spread»";
+addOpLabel(spread, "«ops.spread»");
 
 /**
- * Return a primitive value
+ * Apply the default tagged template function.
  */
-export async function primitive(value) {
-  return value;
+export function template(strings, ...values) {
+  return taggedTemplate(strings, values);
 }
-primitive.toString = () => "«ops.primitive»";
+addOpLabel(template, "«ops.template»");
 
 /**
  * Traverse a path of keys through a tree.
@@ -344,7 +360,7 @@ export const traverse = Tree.traverseOrThrow;
 export function treeHttp(host, ...keys) {
   return constructSiteTree("http:", SiteTree, this, host, ...keys);
 }
-treeHttp.toString = () => "«ops.treeHttp»";
+addOpLabel(treeHttp, "«ops.treeHttp»");
 
 /**
  * A website tree via HTTPS.
@@ -356,7 +372,7 @@ treeHttp.toString = () => "«ops.treeHttp»";
 export function treeHttps(host, ...keys) {
   return constructSiteTree("https:", SiteTree, this, host, ...keys);
 }
-treeHttps.toString = () => "«ops.treeHttps»";
+addOpLabel(treeHttps, "«ops.treeHttps»");
 
 /**
  * If the value is packed but has an unpack method, call it and return that as

package/src/runtime/symbols.js

@@ -0,0 +1,3 @@
+export const codeSymbol = Symbol("code");
+export const scopeSymbol = Symbol("scope");
+export const sourceSymbol = Symbol("source");

package/src/runtime/taggedTemplate.js

@@ -0,0 +1,9 @@
+// Default JavaScript tagged template function splices strings and values
+// together.
+export default function defaultTemplateJoin(strings, values) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    result += values[i] + strings[i + 1];
+  }
+  return result;
+}

package/test/compiler/compile.test.js

@@ -61,6 +61,27 @@ describe("compile", () => {
       "escape characters with `backslash`"
     );
   });
+
+  test("tagged template string array is identical across calls", async () => {
+    let saved;
+    const scope = new ObjectTree({
+      tag: (strings, ...values) => {
+        assert.deepEqual(strings, ["Hello, ", "!"]);
+        if (saved) {
+          assert.equal(strings, saved);
+        } else {
+          saved = strings;
+        }
+        return strings[0] + values[0] + strings[1];
+      },
+    });
+    const fn = compile.expression("=tag`Hello, ${_}!`");
+    const templateFn = await fn.call(null);
+    const alice = await templateFn.call(scope, "Alice");
+    assert.equal(alice, "Hello, Alice!");
+    const bob = await templateFn.call(scope, "Bob");
+    assert.equal(bob, "Hello, Bob!");
+  });
 });
 
 async function assertCompile(text, expected) {