@weborigami/language 0.0.69 → 0.0.71-beta.1

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/extensions.js

@@ -8,6 +8,11 @@ import {
   trailingSlash,
 } from "@weborigami/async-tree";
 
+/** @typedef {import("../../index.ts").ExtensionHandler} ExtensionHandler */
+
+// Track extensions handlers for a given containing tree.
+const handlersForContainer = new Map();
+
 /**
  * If the given path ends in an extension, return it. Otherwise, return the
  * empty string.
@@ -38,18 +43,39 @@ export function extname(path) {
  * @param {string} extension
  */
 export async function getExtensionHandler(parent, extension) {
+  let handlers = handlersForContainer.get(parent);
+  if (handlers) {
+    if (handlers[extension]) {
+      return handlers[extension];
+    }
+  } else {
+    handlers = {};
+    handlersForContainer.set(parent, handlers);
+  }
+
   const handlerName = `${extension.slice(1)}_handler`;
   const parentScope = scope(parent);
-  /** @type {import("../../index.ts").ExtensionHandler} */
-  let extensionHandler = await parentScope?.get(handlerName);
-  if (isUnpackable(extensionHandler)) {
-    // The extension handler itself needs to be unpacked. E.g., if it's a
-    // buffer containing JavaScript file, we need to unpack it to get its
-    // default export.
-    // @ts-ignore
-    extensionHandler = await extensionHandler.unpack();
-  }
-  return extensionHandler;
+
+  /** @type {Promise<ExtensionHandler>} */
+  let handlerPromise = parentScope
+    ?.get(handlerName)
+    .then(async (extensionHandler) => {
+      if (isUnpackable(extensionHandler)) {
+        // The extension handler itself needs to be unpacked. E.g., if it's a
+        // buffer containing JavaScript file, we need to unpack it to get its
+        // default export.
+        // @ts-ignore
+        extensionHandler = await extensionHandler.unpack();
+      }
+      // Update cache with actual handler
+      handlers[extension] = extensionHandler;
+      return extensionHandler;
+    });
+
+  // Cache handler even if it's undefined so we don't look it up again
+  handlers[extension] = handlerPromise;
+
+  return handlerPromise;
 }
 
 /**
@@ -62,7 +88,7 @@ export async function getExtensionHandler(parent, extension) {
  * @param {any} key
  */
 export async function handleExtension(parent, value, key) {
-  if (isPacked(value) && isStringLike(key)) {
+  if (isPacked(value) && isStringLike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
       key = trailingSlash.remove(key);
@@ -89,10 +115,10 @@ export async function handleExtension(parent, value, key) {
         const unpack = handler.unpack;
         if (unpack) {
           // Wrap the unpack function so its only called once per value.
-          let loaded;
+          let loadPromise;
           value.unpack = async () => {
-            loaded ??= await unpack(value, { key, parent });
-            return loaded;
+            loadPromise ??= unpack(value, { key, parent });
+            return loadPromise;
           };
         }
       }

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,26 @@ const lambdaFnMap = new Map();
 export async function array(...items) {
   return Array(...items);
 }
-array.toString = () => "«ops.array»";
+addOpLabel(array, "«ops.array»");
+
+/**
+ * Look up the given key in the scope for the current tree the first time
+ * the key is requested, holding on to the value for future requests.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function cache(key, cache) {
+  if (key in cache) {
+    return cache[key];
+  }
+  // First save a promise for the value
+  const promise = scope.call(this, key);
+  cache[key] = promise;
+  const value = await promise;
+  // Now update with the actual value
+  cache[key] = value;
+  return value;
+}
 
 // The assign op is a placeholder for an assignment declaration.
 // It is only used during parsing -- it shouldn't be executed.
@@ -48,7 +75,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 +98,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 +171,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 +210,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 +223,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 +239,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.
@@ -216,9 +255,6 @@ export function lambda(parameters, code) {
     return lambdaFnMap.get(code);
   }
 
-  // By default, the first input argument is named `_`.
-  parameters ??= ["_"];
-
   /** @this {AsyncTree|null} */
   async function invoke(...args) {
     // Add arguments and @recurse to scope.
@@ -258,7 +294,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 +313,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 +326,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 +340,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 +351,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 +376,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 +388,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

@@ -2,6 +2,8 @@ import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
+import { ops } from "../../src/runtime/internal.js";
+import { stripCodeLocations } from "./stripCodeLocations.js";
 
 const shared = new ObjectTree({
   greet: (name) => `Hello, ${name}!`,
@@ -61,6 +63,51 @@ 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!");
+  });
+
+  test("converts non-local ops.scope calls to ops.cache", async () => {
+    const expression = `
+      (name) => {
+        a: 1
+        b: a            // local, should be left as ops.scope
+        c: nonLocal     // non-local, should be converted to ops.cache
+        d: name         // local, should be left as ops.scope
+      }
+    `;
+    const fn = compile.expression(expression);
+    const code = fn.code;
+    assert.deepEqual(stripCodeLocations(code), [
+      ops.lambda,
+      ["name"],
+      [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.scope, "a"]],
+        ["c", [ops.cache, "nonLocal", {}]],
+        ["d", [ops.scope, "name"]],
+      ],
+    ]);
+  });
 });
 
 async function assertCompile(text, expected) {