@weborigami/language 0.5.4 → 0.5.6

package/src/runtime/expressionObject.js

@@ -6,8 +6,7 @@ import {
   trailingSlash,
   Tree,
 } from "@weborigami/async-tree";
-import getHandlers from "./getHandlers.js";
-import { handleExtension } from "./handlers.js";
+import handleExtension from "./handleExtension.js";
 import { evaluate, ops } from "./internal.js";
 
 /**
@@ -25,11 +24,12 @@ import { evaluate, ops } from "./internal.js";
  *    property getter on the object.
  *
  * @param {*} entries
- * @param {import("@weborigami/types").AsyncTree | null} parent
+ * @param {import("../../index.ts").RuntimeState} [state]
  */
-export default async function expressionObject(entries, parent) {
+export default async function expressionObject(entries, state = {}) {
   // Create the object and set its parent
   const object = {};
+  const parent = state?.object ?? null;
   if (parent !== null && !Tree.isAsyncTree(parent)) {
     throw new TypeError(`Parent must be an AsyncTree or null`);
   }
@@ -86,22 +86,12 @@ export default async function expressionObject(entries, parent) {
         code = value;
       }
 
-      let get;
-      if (extname) {
-        // Key has extension, getter will invoke code then attach unpack method
-        get = async () => {
-          tree ??= new ObjectTree(object);
-          const result = await evaluate.call(tree, code);
-          const handlers = getHandlers(tree);
-          return handleExtension(tree, result, key, handlers);
-        };
-      } else {
-        // No extension, so getter just invokes code.
-        get = async () => {
-          tree ??= new ObjectTree(object);
-          return evaluate.call(tree, code);
-        };
-      }
+      const get = async () => {
+        tree ??= new ObjectTree(object);
+        const newState = Object.assign({}, state, { object: tree });
+        const result = await evaluate(code, newState);
+        return extname ? handleExtension(result, key, tree) : result;
+      };
 
       Object.defineProperty(object, key, {
         configurable: true,

package/src/runtime/functionResultsMap.js

@@ -1,23 +1,16 @@
-import { map, Tree } from "@weborigami/async-tree";
+import { Tree } from "@weborigami/async-tree";
 
 /**
  * When using `get` to retrieve a value from a tree, if the value is a
  * function, invoke it and return the result.
  */
-export default function functionResultsMap(treelike) {
-  return map(treelike, {
+export default async function functionResultsMap(treelike) {
+  return Tree.map(treelike, {
     description: "functionResultsMap",
 
     value: async (sourceValue, sourceKey, tree) => {
-      let resultValue;
-      if (typeof sourceValue === "function") {
-        resultValue = await sourceValue.call(tree);
-        if (Tree.isAsyncTree(resultValue) && !resultValue.parent) {
-          resultValue.parent = tree;
-        }
-      } else {
-        resultValue = sourceValue;
-      }
+      const resultValue =
+        typeof sourceValue === "function" ? await sourceValue() : sourceValue;
       return resultValue;
     },
   });

package/src/runtime/{handlers.js → handleExtension.js}

@@ -2,28 +2,27 @@ import {
   box,
   extension,
   isPacked,
-  isStringLike,
+  isStringlike,
   isUnpackable,
   setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
+import globals from "../project/projectGlobals.js";
+
+let projectGlobals;
 
 /**
  * If the given value is packed (e.g., buffer) and the key is a string-like path
  * that ends in an extension, search for a handler for that extension and, if
  * found, attach it to the value.
  *
- * @param {import("@weborigami/types").AsyncTree} parent
  * @param {any} value
  * @param {any} key
+ * @param {import("@weborigami/types").AsyncTree} [parent]
  */
-export async function handleExtension(parent, value, key, handlers) {
-  if (
-    handlers &&
-    isPacked(value) &&
-    isStringLike(key) &&
-    value.unpack === undefined
-  ) {
+export default async function handleExtension(value, key, parent) {
+  projectGlobals ??= await globals();
+  if (isPacked(value) && isStringlike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
       key = trailingSlash.remove(key);
@@ -38,8 +37,8 @@ export async function handleExtension(parent, value, key, handlers) {
       ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
-      const handlerName = `${extname.slice(1)}.handler`;
-      let handler = await handlers[handlerName];
+      const handlerName = `${extname.slice(1)}_handler`;
+      let handler = await projectGlobals[handlerName];
       if (handler) {
         if (isUnpackable(handler)) {
           // The extension handler itself needs to be unpacked
@@ -57,7 +56,10 @@ export async function handleExtension(parent, value, key, handlers) {
         if (handler.mediaType) {
           value.mediaType = handler.mediaType;
         }
-        setParent(value, parent);
+
+        if (parent) {
+          setParent(value, parent);
+        }
 
         const unpack = handler.unpack;
         if (unpack) {

package/src/runtime/mergeTrees.js

@@ -1,10 +1,4 @@
-import {
-  isPlainObject,
-  isUnpackable,
-  merge,
-  setParent,
-  Tree,
-} from "@weborigami/async-tree";
+import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
 
 /**
  * Create a tree that's the result of merging the given trees.
@@ -12,7 +6,6 @@ import {
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  *
- * @this {AsyncTree|null}
  * @param {(Treelike|null)[]} trees
  */
 export default async function mergeTrees(...trees) {
@@ -54,7 +47,6 @@ export default async function mergeTrees(...trees) {
   }
 
   // Merge the trees.
-  const result = merge(...unpacked);
-  setParent(result, this);
+  const result = Tree.merge(...unpacked);
   return result;
 }

package/src/runtime/ops.js

@@ -3,20 +3,12 @@
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").RuntimeState} RuntimeState
  */
 
-import {
-  deepText,
-  indent,
-  isUnpackable,
-  ObjectTree,
-  scope as scopeFn,
-  text,
-  Tree,
-} from "@weborigami/async-tree";
+import { isUnpackable, symbols, Tree } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
-import getHandlers from "./getHandlers.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
@@ -37,7 +29,6 @@ addOpLabel(addition, "«ops.addition»");
 /**
  * Construct an array.
  *
- * @this {AsyncTree|null}
  * @param {any[]} items
  */
 export async function array(...items) {
@@ -68,7 +59,6 @@ addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 /**
  * Cache the value of the code for an external reference
  *
- * @this {AsyncTree|null}
  * @param {any} cache
  * @param {string} path
  * @param {AnnotatedCode} code
@@ -80,7 +70,7 @@ export async function cache(cache, path, code) {
   }
 
   // Don't await: might get another request for this before promise resolves
-  const promise = await evaluate.call(this, code);
+  const promise = await evaluate(code);
 
   // Save promise so another request will get the same promise
   cache[path] = promise;
@@ -99,13 +89,12 @@ cache.unevaluatedArgs = true;
 /**
  * JavaScript comma operator, returns the last argument.
  *
- * @this {AsyncTree|null}
  * @param  {...AnnotatedCode} args
  */
 export async function comma(...args) {
   let result;
   for (const arg of args) {
-    result = await evaluate.call(this, arg);
+    result = await evaluate(arg);
   }
   return result;
 }
@@ -115,11 +104,10 @@ comma.unevaluatedArgs = true;
 /**
  * Concatenate the given arguments.
  *
- * @this {AsyncTree|null}
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return deepText.call(this, args);
+  return Tree.deepText(args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -135,23 +123,6 @@ export async function construct(constructor, ...args) {
   return Reflect.construct(constructor, args);
 }
 
-/**
- * Return the nth parent of the current tree
- *
- * @this {AsyncTree|null|undefined}
- */
-export function context(n = 0) {
-  let tree = this;
-  for (let i = 0; i < n; i++) {
-    if (!tree) {
-      throw new Error("Internal error: couldn't find tree ancestor.");
-    }
-    tree = tree.parent;
-  }
-  return tree;
-}
-addOpLabel(context, "«ops.context»");
-
 export function division(a, b) {
   return a / b;
 }
@@ -203,65 +174,74 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
 
 /**
  * Files tree for the user's home directory.
- *
- * @this {AsyncTree|null}
  */
 export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
-  // Use the same handlers as the current tree
-  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
+/**
+ * Given the tree currently be using as the context for the runtime, walk up the
+ * parent chain `depth` levels and return that tree.
+ *
+ * @param {number} depth
+ * @param {RuntimeState} state
+ */
+export async function inherited(depth, state) {
+  let current = state.object;
+  for (let i = 0; i < depth; i++) {
+    if (!current) {
+      throw new ReferenceError(
+        `Origami internal error: Can't find context object`
+      );
+    }
+    current = current.parent ?? current[symbols.parent];
+  }
+  return current;
+}
+addOpLabel(inherited, "«ops.inherited»");
+inherited.needsState = true;
+
 /**
  * Return a function that will invoke the given code.
  *
- * @this {AsyncTree|null}
  * @param {string[]} parameters
  * @param {AnnotatedCode} code
  */
-export function lambda(parameters, code) {
-  const context = this;
+export function lambda(parameters, code, state = {}) {
+  const stack = state.stack ?? [];
 
-  /** @this {Treelike|null} */
   async function invoke(...args) {
-    let target;
+    let newState;
     if (parameters.length === 0) {
       // No parameters
-      target = context;
+      newState = state;
     } else {
-      // Add arguments to scope.
-      const ambients = {};
+      // Create a stack frame for the parameters
+      const frame = {};
       for (const parameter of parameters) {
         const parameterName = parameter[1];
-        ambients[parameterName] = args.shift();
+        frame[parameterName] = args.shift();
       }
-      Object.defineProperty(ambients, codeSymbol, {
+      // Record which code this stack frame is associated with
+      Object.defineProperty(frame, codeSymbol, {
         value: code,
         enumerable: false,
       });
-      const ambientTree = new ObjectTree(ambients);
-      ambientTree.parent = context;
-      target = ambientTree;
-    }
-
-    let result = await evaluate.call(target, code);
-
-    // Bind a function result to the ambients so that it has access to the
-    // parameter values -- i.e., like a closure.
-    if (result instanceof Function) {
-      const resultCode = result.code;
-      result = result.bind(target);
-      if (code) {
-        // Copy over Origami code
-        result.code = resultCode;
-      }
+      const newStack = stack.slice();
+      newStack.push(frame);
+      newState = Object.assign({}, state, { stack: newStack });
     }
 
+    const result = await evaluate(code, newState);
     return result;
   }
 
+  // Retain a reference to the original code for debugging, and so that functions
+  // can be compared by their code (e.g., for caching purposes).
+  invoke.code = code;
+
   // We set the `length` property on the function so that Tree.traverseOrThrow()
   // will correctly identify how many parameters it wants. This is unorthodox
   // but doesn't appear to affect other behavior.
@@ -270,11 +250,11 @@ export function lambda(parameters, code) {
     value: fnLength,
   });
 
-  invoke.code = code;
   return invoke;
 }
 addOpLabel(lambda, "«ops.lambda»");
 lambda.unevaluatedArgs = true;
+lambda.needsState = true;
 
 export function lessThan(a, b) {
   return a < b;
@@ -356,11 +336,10 @@ addOpLabel(logicalOr, "«ops.logicalOr»");
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
- * @this {AsyncTree|null}
  * @param {any[]} trees
  */
 export async function merge(...trees) {
-  return mergeTrees.call(this, ...trees);
+  return mergeTrees(...trees);
 }
 addOpLabel(merge, "«ops.merge»");
 
@@ -404,59 +383,71 @@ addOpLabel(nullishCoalescing, "«ops.nullishCoalescing»");
  * parameter's, and the values will be the results of evaluating the
  * corresponding code values in `obj`.
  *
- * @this {AsyncTree|null}
  * @param {any[]} entries
  */
 export async function object(...entries) {
-  return expressionObject(entries, this);
+  const state = entries.pop();
+  return expressionObject(entries, state);
 }
 addOpLabel(object, "«ops.object»");
 object.unevaluatedArgs = true;
+object.needsState = true;
 
-export function optionalTraverse(treelike, key) {
-  if (!treelike) {
-    return undefined;
-  }
-  return Tree.traverseOrThrow(treelike, key);
+/**
+ * Return the stack frame that's `depth` levels up the stack.
+ *
+ * @param {number} depth
+ * @param {RuntimeState} state
+ */
+export async function params(depth, state = {}) {
+  const stack = state.stack ?? [];
+  return stack[stack.length - 1 - depth];
 }
-addOpLabel(optionalTraverse, "«ops.optionalTraverse");
+addOpLabel(params, "«ops.params»");
+params.needsState = true;
+
+// export function optionalTraverse(treelike, key) {
+//   if (!treelike) {
+//     return undefined;
+//   }
+//   return Tree.traverseOrThrow(treelike, key);
+// }
+// addOpLabel(optionalTraverse, "«ops.optionalTraverse");
 
 /**
  * Return the indicated property
  *
- * @param {any} obj
+ * @param {any} object
  * @param {string} key
  */
-export async function property(obj, key) {
-  if (obj == null) {
+export async function property(object, key) {
+  if (object == null) {
     throw new ReferenceError();
   }
 
-  if (isUnpackable(obj)) {
-    obj = await obj.unpack();
-  } else if (typeof obj === "string") {
-    obj = new String(obj);
-  } else if (typeof obj === "number") {
-    obj = new Number(obj);
+  if (isUnpackable(object)) {
+    object = await object.unpack();
+  } else if (typeof object === "string") {
+    object = new String(object);
+  } else if (typeof object === "number") {
+    object = new Number(object);
   }
 
-  if (key in obj) {
+  if (key in object) {
     // Object defines the property, get it
-    let value = obj[key];
+    let value = object[key];
     // Is value an instance method? Copied from ObjectTree.
     const isInstanceMethod =
-      !(obj instanceof Function) &&
-      value instanceof Function &&
-      !Object.hasOwn(obj, key);
+      value instanceof Function && !Object.hasOwn(object, key);
     if (isInstanceMethod) {
       // Bind it to the object
-      value = value.bind(obj);
+      value = value.bind(object);
     }
     return value;
   }
 
   // Handle as tree traversal
-  return Tree.traverseOrThrow(obj, key);
+  return Tree.traverseOrThrow(object, key);
 }
 addOpLabel(property, "«ops.property»");
 
@@ -467,13 +458,9 @@ addOpLabel(remainder, "«ops.remainder»");
 
 /**
  * Files tree for the filesystem root.
- *
- * @this {AsyncTree|null}
  */
 export async function rootDirectory(...keys) {
   const tree = new OrigamiFiles("/");
-  // Use the same handlers as the current tree
-  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
@@ -481,17 +468,15 @@ addOpLabel(rootDirectory, "«ops.rootDirectory»");
 /**
  * Return the scope of the current tree
  *
- * @this {AsyncTree|null}
- * @param {AsyncTree|null} [context]
+ * @param {AsyncTree} parent
  */
-export async function scope(context) {
-  if (context === undefined) {
-    context = this;
-  }
-  if (!context) {
-    return null;
+export async function scope(parent) {
+  if (!parent) {
+    throw new ReferenceError(
+      "Tried to find a value in scope, but no container was provided as the parent."
+    );
   }
-  return scopeFn(context);
+  return Tree.scope(parent);
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -535,7 +520,7 @@ addOpLabel(subtraction, "«ops.subtraction»");
  * Apply the tree indent tagged template function.
  */
 export async function templateIndent(strings, ...values) {
-  return indent(strings, ...values);
+  return Tree.indent(strings, ...values);
 }
 addOpLabel(templateIndent, "«ops.templateIndent»");
 
@@ -543,7 +528,7 @@ addOpLabel(templateIndent, "«ops.templateIndent»");
  * Apply the tree tagged template function.
  */
 export async function templateText(strings, ...values) {
-  return text(strings, ...values);
+  return Tree.text(strings, ...values);
 }
 addOpLabel(templateText, "«ops.templateText»");
 

package/test/compiler/compile.test.js

@@ -1,10 +1,10 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { 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 { assertCodeEqual } from "./codeHelpers.js";
 
-const sharedGlobals = {
+const globals = {
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
 };
@@ -43,21 +43,24 @@ describe("compile", () => {
     );
   });
 
-  test.skip("merge", async () => {
+  test("merge", async () => {
     {
-      const scope = new ObjectTree({
+      const globals = {
         more: {
           b: 2,
         },
-      });
-      const fn = compile.expression(`
+      };
+      const fn = compile.expression(
+        `
         {
           a: 1
           ...more
           c: a
         }
-      `);
-      const result = await fn.call(scope);
+      `,
+        { globals }
+      );
+      const result = await fn();
       assert.deepEqual(await Tree.plain(result), {
         a: 1,
         b: 2,
@@ -78,10 +81,8 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}", {
-      globals: sharedGlobals,
-    });
-    const object = await fn.call(null);
+    const fn = compile.expression("{ a: { b = name }}", { globals });
+    const object = await fn();
     assert.deepEqual(await object.a.b, "Alice");
   });
 
@@ -89,8 +90,8 @@ describe("compile", () => {
     const defineTemplateFn = compile.templateDocument(
       "Documents can contain ` backticks"
     );
-    const templateFn = await defineTemplateFn.call(null);
-    const value = await templateFn.call(null);
+    const templateFn = await defineTemplateFn();
+    const value = await templateFn();
     assert.deepEqual(value, "Documents can contain ` backticks");
   });
 
@@ -115,8 +116,8 @@ describe("compile", () => {
         return strings[0] + values[0] + strings[1];
       },
     };
-    const program = compile.expression("=tag`Hello, ${_}!`", { globals });
-    const lambda = await program.call(null);
+    const program = compile.expression("(_) => tag`Hello, ${_}!`", { globals });
+    const lambda = await program();
     const alice = await lambda("Alice");
     assert.equal(alice, "Hello, Alice!");
     const bob = await lambda("Bob");
@@ -126,9 +127,9 @@ describe("compile", () => {
 
 async function assertCompile(text, expected, options = {}) {
   const mode = options.mode ?? "program";
-  const fn = compile.expression(text, { globals: sharedGlobals, mode });
-  const target = options.target ?? null;
-  let result = await fn.call(target);
+  const parent = options.target ?? null;
+  const fn = compile.expression(text, { globals, mode, parent });
+  let result = await fn();
   if (Tree.isTreelike(result)) {
     result = await Tree.plain(result);
   }