@weborigami/language 0.0.72 → 0.0.73

package/package.json

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

package/src/compiler/compile.js

@@ -3,7 +3,9 @@ import { createExpressionFunction } from "../runtime/expressionFunction.js";
 import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
 
-function compile(source, startRule) {
+function compile(source, options) {
+  const { startRule } = options;
+  const scopeCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
@@ -12,20 +14,25 @@ function compile(source, startRule) {
     startRule,
   });
   const cache = {};
-  const modified = cacheNonLocalScopeReferences(code, cache);
+  const modified = scopeCaching
+    ? cacheExternalScopeReferences(code, cache)
+    : code;
   // const modified = code;
   const fn = createExpressionFunction(modified);
   return fn;
 }
 
-export function expression(source) {
-  return compile(source, "expression");
+export function expression(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "expression",
+  });
 }
 
 // Given code containing ops.scope calls, upgrade them to ops.cache calls unless
 // they refer to local variables: variables defined by object literals or lambda
 // parameters.
-export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
+export function cacheExternalScopeReferences(code, cache, locals = {}) {
   const [fn, ...args] = code;
 
   let additionalLocalNames;
@@ -67,7 +74,7 @@ export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
       // be preferable to only descend into instructions. This would require
       // surrounding ops.lambda parameters with ops.literal, and ops.object
       // entries with ops.array.
-      return cacheNonLocalScopeReferences(child, cache, updatedLocals);
+      return cacheExternalScopeReferences(child, cache, updatedLocals);
     } else {
       return child;
     }
@@ -79,6 +86,9 @@ export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
   return modified;
 }
 
-export function templateDocument(source) {
-  return compile(source, "templateDocument");
+export function templateDocument(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "templateDocument",
+  });
 }

package/src/runtime/ops.js

@@ -39,7 +39,7 @@ function addOpLabel(op, label) {
  * @param {any[]} items
  */
 export async function array(...items) {
-  return Array(...items);
+  return items;
 }
 addOpLabel(array, "«ops.array»");
 

package/test/runtime/ops.test.js

@@ -5,6 +5,12 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
+  test("ops.array creates an array", async () => {
+    const code = createCode([ops.array, 1, 2, 3]);
+    const result = await evaluate.call(null, code);
+    assert.deepEqual(result, [1, 2, 3]);
+  });
+
   test("ops.cache looks up a value in scope and memoizes it", async () => {
     let count = 0;
     const tree = new ObjectTree({