@weborigami/language 0.5.3 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.3",
-    "@weborigami/types": "0.5.3",
+    "@weborigami/async-tree": "0.5.5",
+    "@weborigami/types": "0.5.5",
     "watcher": "2.3.1",
     "yaml": "2.8.1"
   },

package/src/compiler/parserHelpers.js

@@ -170,7 +170,7 @@ export function makeCall(target, args, location) {
 
   let fnCall;
   const op = args[0];
-  if (op === markers.traverse || op === ops.optionalTraverse) {
+  if (op === markers.traverse /* || op === ops.optionalTraverse */) {
     // Traverse
     const keys = args.slice(1);
     fnCall = [target, ...keys];

package/src/runtime/errors.js

@@ -2,9 +2,9 @@
 
 import {
   box,
-  scope as scopeFn,
   trailingSlash,
   TraverseError,
+  Tree,
 } from "@weborigami/async-tree";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -39,7 +39,7 @@ export function attachWarning(value, message) {
 
 export async function builtinReferenceError(tree, builtins, key) {
   // See if the key is in scope (but not as a builtin)
-  const scope = scopeFn(tree);
+  const scope = await Tree.scope(tree);
   const value = await scope.get(key);
   let message;
   if (value === undefined) {

package/src/runtime/functionResultsMap.js

@@ -1,23 +1,18 @@
-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.call(tree)
+          : sourceValue;
       return resultValue;
     },
   });

package/src/runtime/handlers.js

@@ -2,7 +2,7 @@ import {
   box,
   extension,
   isPacked,
-  isStringLike,
+  isStringlike,
   isUnpackable,
   setParent,
   trailingSlash,
@@ -21,7 +21,7 @@ export async function handleExtension(parent, value, key, handlers) {
   if (
     handlers &&
     isPacked(value) &&
-    isStringLike(key) &&
+    isStringlike(key) &&
     value.unpack === undefined
   ) {
     const hasSlash = trailingSlash.has(key);

package/src/runtime/mergeTrees.js

@@ -1,7 +1,6 @@
 import {
   isPlainObject,
   isUnpackable,
-  merge,
   setParent,
   Tree,
 } from "@weborigami/async-tree";
@@ -54,7 +53,7 @@ export default async function mergeTrees(...trees) {
   }
 
   // Merge the trees.
-  const result = merge(...unpacked);
+  const result = Tree.merge(...unpacked);
   setParent(result, this);
   return result;
 }

package/src/runtime/ops.js

@@ -5,15 +5,7 @@
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
-import {
-  deepText,
-  indent,
-  isUnpackable,
-  ObjectTree,
-  scope as scopeFn,
-  text,
-  Tree,
-} from "@weborigami/async-tree";
+import { isUnpackable, ObjectTree, Tree } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
 import getHandlers from "./getHandlers.js";
@@ -119,7 +111,7 @@ comma.unevaluatedArgs = true;
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return deepText.call(this, args);
+  return Tree.deepText.call(this, args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -413,13 +405,13 @@ 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 optionalTraverse(treelike, key) {
+//   if (!treelike) {
+//     return undefined;
+//   }
+//   return Tree.traverseOrThrow(treelike, key);
+// }
+// addOpLabel(optionalTraverse, "«ops.optionalTraverse");
 
 /**
  * Return the indicated property
@@ -491,7 +483,7 @@ export async function scope(context) {
   if (!context) {
     return null;
   }
-  return scopeFn(context);
+  return Tree.scope(context);
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -535,7 +527,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 +535,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/parse.test.js

@@ -1125,12 +1125,12 @@ Body`,
     assertParse("objectPublicKey", `"foo bar"`, "foo bar", "shell", false);
   });
 
-  test.skip("optionalChaining", () => {
-    assertParse("optionalChaining", "?.key", [
-      ops.optionalTraverse,
-      [ops.literal, "key"],
-    ]);
-  });
+  // test.skip("optionalChaining", () => {
+  //   assertParse("optionalChaining", "?.key", [
+  //     ops.optionalTraverse,
+  //     [ops.literal, "key"],
+  //   ]);
+  // });
 
   test("parenthesesArguments", () => {
     assertParse("parenthesesArguments", "()", [undefined]);

package/test/runtime/functionResultsMap.test.js

@@ -1,21 +1,17 @@
-import { ObjectTree, Tree, scope } from "@weborigami/async-tree";
+import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import functionResultsMap from "../../src/runtime/functionResultsMap.js";
 
 describe("functionResultsMap", () => {
-  test("get() invokes functions using scope, returns other values as is", async () => {
-    const parent = new ObjectTree({
-      message: "Hello",
-    });
+  test("get() invokes functions, returns other values as is", async () => {
     const tree = new ObjectTree({
-      fn: /** @this {import("@weborigami/types").AsyncTree} */ function () {
-        return scope(this).get("message");
+      fn: function () {
+        return "Hello";
       },
       string: "string",
     });
-    tree.parent = parent;
-    const fixture = functionResultsMap(tree);
+    const fixture = await functionResultsMap(tree);
     assert.deepEqual(await Tree.plain(fixture), {
       fn: "Hello",
       string: "string",

package/test/runtime/ops.test.js

@@ -280,10 +280,10 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.optionalTraverse", async () => {
-    assert.equal(await ops.optionalTraverse(null, "a"), undefined);
-    assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
-  });
+  // test("ops.optionalTraverse", async () => {
+  //   assert.equal(await ops.optionalTraverse(null, "a"), undefined);
+  //   assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
+  // });
 
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 1));