@weborigami/language 0.3.3 → 0.3.4-jse.5

package/src/runtime/jsGlobals.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+
+/**
+ * The complete set of support JavaScript globals and global-like values.
+ *
+ * See
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects.
+ * That page lists some things like `TypedArrays` which are not globals so are
+ * omitted here.
+ *
+ * Also includes
+ * Fetch API
+ * URL API
+ */
+export default {
+  AggregateError,
+  Array,
+  ArrayBuffer,
+  Atomics,
+  BigInt,
+  BigInt64Array,
+  BigUint64Array,
+  Boolean,
+  DataView,
+  Date,
+  Error,
+  EvalError,
+  FinalizationRegistry,
+  Float32Array,
+  Float64Array,
+  Function,
+  Headers,
+  Infinity,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Intl,
+  // @ts-ignore Iterator does exist despite what TypeScript thinks
+  Iterator,
+  JSON,
+  Map,
+  Math,
+  NaN,
+  Number,
+  Object,
+  Promise,
+  Proxy,
+  RangeError,
+  ReferenceError,
+  Reflect,
+  RegExp,
+  Request,
+  Response,
+  Set,
+  SharedArrayBuffer,
+  String,
+  Symbol,
+  SyntaxError,
+  TypeError,
+  URIError,
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  WeakMap,
+  WeakRef,
+  WeakSet,
+  decodeURI,
+  decodeURIComponent,
+  encodeURI,
+  encodeURIComponent,
+  eval,
+  false: false, // treat like a global
+  fetch: fetchWrapper, // special case
+  globalThis,
+  import: importWrapper, // not a function in JS but acts like one
+  isFinite,
+  isNaN,
+  null: null, // treat like a global
+  parseFloat,
+  parseInt,
+  true: true, // treat like a global
+  undefined,
+};
+
+async function fetchWrapper(resource, options) {
+  const response = await fetch(resource, options);
+  return response.ok ? await response.arrayBuffer() : undefined;
+}
+
+/** @this {import("@weborigami/types").AsyncTree|null|undefined} */
+async function importWrapper(modulePath) {
+  // Walk up parent tree looking for a FileTree or other object with a `path`
+  /** @type {any} */
+  let current = this;
+  while (current && !("path" in current)) {
+    current = current.parent;
+  }
+  if (!current) {
+    throw new TypeError(
+      "Modules can only be imported from a folder or other object with a path property."
+    );
+  }
+  const filePath = path.resolve(current.path, modulePath);
+  return import(filePath);
+}

package/src/runtime/mergeTrees.js

@@ -53,11 +53,6 @@ export default async function mergeTrees(...trees) {
     return result;
   }
 
-  // If all trees are arrays, return an array.
-  if (unpacked.every((tree) => Array.isArray(tree))) {
-    return unpacked.flat();
-  }
-
   // Merge the trees.
   const result = merge(...unpacked);
   setParent(result, this);

package/src/runtime/ops.js

@@ -11,17 +11,16 @@ import {
   deepText,
   isUnpackable,
   scope as scopeFn,
-  setParent,
-  concat as treeConcat,
+  text as templateFunctionTree,
 } from "@weborigami/async-tree";
 import os from "node:os";
-import taggedTemplateIndent from "../../src/runtime/taggedTemplateIndent.js";
-import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 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";
 import { codeSymbol } from "./symbols.js";
+import templateFunctionIndent from "./templateIndent.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -67,25 +66,35 @@ export function bitwiseXor(a, b) {
 addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 
 /**
- * Like ops.scope, but only searches for a builtin at the top of the scope
- * chain.
+ * Cache the value of the code for an external reference
  *
  * @this {AsyncTree|null}
+ * @param {any} cache
+ * @param {string} path
+ * @param {AnnotatedCode} code
  */
-export async function builtin(key) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
+export async function cache(cache, path, code) {
+  if (path in cache) {
+    // Cache hit
+    return cache[path];
   }
 
-  const builtins = Tree.root(this);
-  const value = await builtins.get(key);
-  if (value === undefined) {
-    throw await builtinReferenceError(this, builtins, key);
-  }
+  // Don't await: might get another request for this before promise resolves
+  const promise = await evaluate.call(this, code);
+
+  // Save promise so another request will get the same promise
+  cache[path] = promise;
+
+  // Now wait for the value
+  const value = await promise;
+
+  // Update the cache with the actual value
+  cache[path] = value;
 
   return value;
 }
-addOpLabel(builtin, "«ops.builtin»");
+addOpLabel(cache, "«ops.cache»");
+cache.unevaluatedArgs = true;
 
 /**
  * JavaScript comma operator, returns the last argument.
@@ -105,7 +114,7 @@ addOpLabel(comma, "«ops.comma»");
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return treeConcat.call(this, args);
+  return deepText.call(this, args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -114,28 +123,29 @@ export async function conditional(condition, truthy, falsy) {
   return value instanceof Function ? await value() : value;
 }
 
+export async function construct(constructor, ...args) {
+  if (isUnpackable(constructor)) {
+    constructor = await constructor.unpack();
+  }
+  return Reflect.construct(constructor, args);
+}
+
 /**
- * Construct a document object by invoking the body code (a lambda) and adding
- * the resulting text to the front data.
+ * Return the nth parent of the current tree
  *
- * @this {AsyncTree|null}
- * @param {any} frontData
- * @param {AnnotatedCode} bodyCode
+ * @this {AsyncTree|null|undefined}
  */
-export async function document(frontData, bodyCode) {
-  const context = new ObjectTree(frontData);
-  context.parent = this;
-  const bodyFn = await evaluate.call(context, bodyCode);
-  const body = await bodyFn();
-  const object = {
-    ...frontData,
-    "@text": body,
-  };
-  setParent(object, this);
-  return object;
-}
-addOpLabel(document, "«ops.document");
-document.unevaluatedArgs = true;
+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;
@@ -153,36 +163,22 @@ export function exponentiation(a, b) {
 addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
- * Look up the given key as an external reference and cache the value for future
- * requests.
+ * Flatten the values of the given trees
  *
- * @this {AsyncTree|null}
+ * @param {...any} args
  */
-export async function external(path, code, cache) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
-  }
-
-  if (path in cache) {
-    // Cache hit
-    return cache[path];
-  }
-
-  // Don't await: might get another request for this before promise resolves
-  const promise = evaluate.call(this, code);
-  // Save promise so another request will get the same promise
-  cache[path] = promise;
-
-  // Now wait for the value
-  const value = await promise;
-
-  // Update the cache with the actual value
-  cache[path] = value;
+export async function flat(...args) {
+  const arrays = await Promise.all(
+    args.map(async (arg) =>
+      arg instanceof Array || typeof arg !== "object"
+        ? arg
+        : await Tree.values(arg)
+    )
+  );
 
-  return value;
+  return arrays.flat();
 }
-addOpLabel(external, "«ops.external»");
-external.unevaluatedArgs = true;
+addOpLabel(flat, "«ops.flat»");
 
 /**
  * This op is only used during parsing. It signals to ops.object that the
@@ -205,30 +201,14 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  *
  * @this {AsyncTree|null}
  */
-export async function homeDirectory() {
+export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
-  tree.parent = this ? Tree.root(this) : null;
-  return tree;
+  // Use the same handlers as the current tree
+  tree.handlers = getHandlers(this);
+  return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
-/**
- * Search the parent's scope -- i.e., exclude the current tree -- for the given
- * key.
- *
- * @this {AsyncTree|null}
- * @param {*} key
- */
-export async function inherited(key) {
-  if (!this?.parent) {
-    return undefined;
-  }
-  const parentScope = scopeFn(this.parent);
-  const value = await parentScope.get(key);
-  return value;
-}
-addOpLabel(inherited, "«ops.inherited»");
-
 /**
  * Return a function that will invoke the given code.
  *
@@ -367,61 +347,12 @@ addOpLabel(logicalOr, "«ops.logicalOr»");
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
  * @this {AsyncTree|null}
- * @param {AnnotatedCode[]} codes
+ * @param {any[]} trees
  */
-export async function merge(...codes) {
-  // First pass: evaluate the direct property entries in a single object
-  let treeSpreads = false;
-  const directEntries = [];
-  for (const code of codes) {
-    if (code[0] === object) {
-      directEntries.push(...code.slice(1));
-    } else {
-      treeSpreads = true;
-    }
-  }
-
-  const directObject = directEntries
-    ? await expressionObject(directEntries, this)
-    : null;
-  if (!treeSpreads) {
-    // No tree spreads, we're done
-    return directObject;
-  }
-
-  // If we have direct property entries, create a context for them. The
-  // `expressionObject` function will set the object's parent symbol to `this`.
-  // Tree.from will call the ObjectTree constructor, which will use that symbol
-  // to set the parent for the new tree to `this`.
-  const context = directObject ? Tree.from(directObject) : this;
-
-  // Second pass: evaluate the trees. For the trees which are direct property
-  // entries, we'll copy over the values we've already calculated. We can't
-  // reuse the `directObject` as is because in a merge we need to respect the
-  // order in which the properties are defined. Trees that aren't direct
-  // property entries are evaluated with the direct property entries in scope.
-  const trees = await Promise.all(
-    codes.map(async (code) => {
-      if (code[0] === object) {
-        // Using the code as reference, create a new object with the direct
-        // property values we've already calculated.
-        const object = {};
-        for (const [key] of code.slice(1)) {
-          // @ts-ignore directObject will always be defined
-          object[key] = directObject[key];
-        }
-        setParent(object, this);
-        return object;
-      } else {
-        return evaluate.call(context, code);
-      }
-    })
-  );
-
+export async function merge(...trees) {
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
-merge.unevaluatedArgs = true;
 
 export function multiplication(a, b) {
   return a * b;
@@ -472,6 +403,14 @@ export async function object(...entries) {
 addOpLabel(object, "«ops.object»");
 object.unevaluatedArgs = true;
 
+export function optionalTraverse(treelike, key) {
+  if (!treelike) {
+    return undefined;
+  }
+  return Tree.traverseOrThrow(treelike, key);
+}
+addOpLabel(optionalTraverse, "«ops.optionalTraverse");
+
 export function remainder(a, b) {
   return a % b;
 }
@@ -482,31 +421,28 @@ addOpLabel(remainder, "«ops.remainder»");
  *
  * @this {AsyncTree|null}
  */
-export async function rootDirectory(key) {
-  let tree = new OrigamiFiles("/");
-  // We set the builtins as the parent because logically the filesystem root is
-  // outside the project. This ignores the edge case where the project itself is
-  // the root of the filesystem and has a config file.
-  tree.parent = this ? Tree.root(this) : null;
-  return key ? tree.get(key) : tree;
+export async function rootDirectory(...keys) {
+  const tree = new OrigamiFiles("/");
+  // Use the same handlers as the current tree
+  tree.handlers = getHandlers(this);
+  return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
 
 /**
- * Look up the given key in the scope for the current tree.
+ * Return the scope of the current tree
  *
  * @this {AsyncTree|null}
+ * @param {AsyncTree|null} [context]
  */
-export async function scope(key) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
+export async function scope(context) {
+  if (context === undefined) {
+    context = this;
   }
-  const scope = scopeFn(this);
-  const value = await scope.get(key);
-  if (value === undefined && key !== "undefined") {
-    throw await scopeReferenceError(scope, key);
+  if (!context) {
+    return null;
   }
-  return value;
+  return scopeFn(context);
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -547,25 +483,20 @@ export function subtraction(a, b) {
 addOpLabel(subtraction, "«ops.subtraction»");
 
 /**
- * Apply the default tagged template function.
- */
-export async function template(strings, ...values) {
-  return deepText(strings, ...values);
-}
-addOpLabel(template, "«ops.template»");
-
-/**
- * Apply the tagged template indent function.
+ * Apply the tree indent tagged template function.
  */
 export async function templateIndent(strings, ...values) {
-  return taggedTemplateIndent(strings, ...values);
+  return templateFunctionIndent(strings, ...values);
 }
-addOpLabel(templateIndent, "«ops.templateIndent");
+addOpLabel(templateIndent, "«ops.templateIndent»");
 
 /**
- * Traverse a path of keys through a tree.
+ * Apply the tree tagged template function.
  */
-export const traverse = Tree.traverseOrThrow;
+export async function templateTree(strings, ...values) {
+  return templateFunctionTree(strings, ...values);
+}
+addOpLabel(templateTree, "«ops.templateTree»");
 
 export function unaryMinus(a) {
   return -a;

package/src/runtime/symbols.js

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

package/src/runtime/{taggedTemplateIndent.js → templateIndent.js}

@@ -1,4 +1,4 @@
-import { concat, toString, Tree } from "@weborigami/async-tree";
+import { deepText, toString, Tree } from "@weborigami/async-tree";
 
 const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
 
@@ -19,7 +19,7 @@ export default async function indent(strings, ...values) {
   }
   const { blockIndentations, strings: modifiedStrings } = modified;
   const valueTexts = await Promise.all(
-    values.map((value) => (Tree.isTreelike(value) ? concat(value) : value))
+    values.map((value) => (Tree.isTreelike(value) ? deepText(value) : value))
   );
   return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }

package/test/compiler/codeHelpers.js

@@ -13,7 +13,9 @@ export function assertCodeEqual(actual, expected) {
  * @returns {import("../../index.ts").AnnotatedCode}
  */
 export function createCode(array) {
-  const code = array;
+  const code = array.map((item) =>
+    item instanceof Array ? createCode(item) : item
+  );
   /** @type {any} */ (code).location = {
     end: 0,
     source: {

package/test/compiler/compile.test.js

@@ -1,14 +1,13 @@
-import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { ObjectTree, 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 { assertCodeEqual } from "./codeHelpers.js";
 
-const shared = new ObjectTree({
+const sharedGlobals = {
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
-});
+};
 
 describe("compile", () => {
   test("array", async () => {
@@ -20,16 +19,52 @@ describe("compile", () => {
   test("functionComposition", async () => {
     await assertCompile("greet()", "Hello, undefined!");
     await assertCompile("greet(name)", "Hello, Alice!");
+    await assertCompile("greet(name)", "Hello, Alice!", { mode: "jse" });
     await assertCompile("greet 'world'", "Hello, world!");
   });
 
-  test("tree", async () => {
-    const fn = compile.expression("{ message = greet(name) }");
-    const tree = await fn.call(null);
-    tree[symbols.parent] = shared;
-    assert.deepEqual(await Tree.plain(tree), {
+  test("angle bracket path", async () => {
+    await assertCompile("<data>", "Bob", {
+      target: {
+        data: "Bob",
+      },
+    });
+  });
+
+  test("object literal", async () => {
+    await assertCompile("{ message = greet(name) }", {
       message: "Hello, Alice!",
     });
+    await assertCompile(
+      "{ message = greet(name) }",
+      {
+        message: "Hello, Alice!",
+      },
+      { mode: "jse" }
+    );
+  });
+
+  test.skip("merge", async () => {
+    {
+      const scope = new ObjectTree({
+        more: {
+          b: 2,
+        },
+      });
+      const fn = compile.expression(`
+        {
+          a: 1
+          ...more
+          c: a
+        }
+      `);
+      const result = await fn.call(scope);
+      assert.deepEqual(await Tree.plain(result), {
+        a: 1,
+        b: 2,
+        c: 1,
+      });
+    }
   });
 
   test("number", async () => {
@@ -44,8 +79,10 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}");
-    const object = await fn.call(shared);
+    const fn = compile.expression("{ a: { b = name }}", {
+      globals: sharedGlobals,
+    });
+    const object = await fn.call(null);
     assert.deepEqual(await object.a.b, "Alice");
   });
 
@@ -68,7 +105,7 @@ describe("compile", () => {
 
   test("tagged template string array is identical across calls", async () => {
     let saved;
-    const scope = new ObjectTree({
+    const globals = {
       tag: (strings, ...values) => {
         assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
@@ -78,30 +115,23 @@ describe("compile", () => {
         }
         return strings[0] + values[0] + strings[1];
       },
-    });
-    const program = compile.expression("=tag`Hello, ${_}!`");
-    const lambda = await program.call(scope);
+    };
+    const program = compile.expression("=tag`Hello, ${_}!`", { globals });
+    const lambda = await program.call(null);
     const alice = await lambda("Alice");
     assert.equal(alice, "Hello, Alice!");
     const bob = await lambda("Bob");
     assert.equal(bob, "Hello, Bob!");
   });
-
-  test("can apply a macro", async () => {
-    const literal = [ops.literal, 1];
-    const expression = `{ a: literal }`;
-    const fn = compile.expression(expression, {
-      macros: {
-        literal,
-      },
-    });
-    const code = fn.code;
-    assertCodeEqual(code, [ops.object, ["a", 1]]);
-  });
 });
 
-async function assertCompile(text, expected) {
-  const fn = compile.expression(text);
-  const result = await fn.call(shared);
+async function assertCompile(text, expected, options = {}) {
+  const mode = options.mode ?? "shell";
+  const fn = compile.expression(text, { globals: sharedGlobals, mode });
+  const target = options.target ?? null;
+  let result = await fn.call(target);
+  if (Tree.isTreelike(result)) {
+    result = await Tree.plain(result);
+  }
   assert.deepEqual(result, expected);
 }