@weborigami/language 0.3.4-jse.8 → 0.3.4-jse.9

package/package.json

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

package/src/compiler/optimize.js

@@ -56,7 +56,7 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const keys = entries.map(entryKey);
+      const keys = entries.map((entry) => entryKey(entry));
       locals.push(keys);
       break;
   }
@@ -70,13 +70,16 @@ export default function optimize(code, options = {}) {
       } else if (op === ops.object && index > 0) {
         const [key, value] = child;
         const adjustedLocals = avoidLocalRecursion(locals, key);
-        return [
-          key,
-          optimize(/** @type {AnnotatedCode} */ (value), {
-            ...options,
-            locals: adjustedLocals,
-          }),
-        ];
+        return annotate(
+          [
+            key,
+            optimize(/** @type {AnnotatedCode} */ (value), {
+              ...options,
+              locals: adjustedLocals,
+            }),
+          ],
+          child.location
+        );
       } else if (Array.isArray(child) && "location" in child) {
         // Review: Aside from ops.object (above), what non-instruction arrays
         // does this descend into?
@@ -191,6 +194,7 @@ function inlineLiteral(code) {
 function localReference(key, locals, location) {
   const normalized = trailingSlash.remove(key);
   const depth = getLocalReferenceDepth(locals, normalized);
+  /** @type {any[]} */
   const context = [ops.context];
   if (depth > 0) {
     context.push(depth);
@@ -310,6 +314,7 @@ function resolvePath(code, globals, locals, cache) {
 
 function scopeCall(locals, location) {
   const depth = locals.length;
+  /** @type {any[]} */
   const code = [ops.scope];
   if (depth > 0) {
     // Add context for appropriate depth to scope call

package/src/compiler/origami.pegjs

@@ -866,8 +866,8 @@ uriKey
 // A single character in a URI key
 uriKeyChar
   // Accept anything that doesn't end the URI key or path
-  // Note: Peggy doesn't support `/s` so we list space and tab explicitly.
-  = [^/,\)\]\} \t]
+  // Reject whitespace; see notes for `whitespace` term
+  = char:[^/,\)\]\}] !&{ return /\s/.test(char); } { return char; }
   / escapedChar
 
 // A slash-separated path of keys: `a/b/c`

package/src/compiler/parse.js

@@ -285,7 +285,7 @@ function peg$parse(input, options) {
   var peg$r7 = /^[gimuy]/;
   var peg$r8 = /^[^\/\n\r]/;
   var peg$r9 = /^[^\n\r]/;
-  var peg$r10 = /^[^\/,)\]} \t]/;
+  var peg$r10 = /^[^\/,)\]}]/;
   var peg$r11 = /^[a-z]/;
   var peg$r12 = /^[a-z0-9+-.]/;
   var peg$r13 = /^[:]/;
@@ -399,7 +399,7 @@ function peg$parse(input, options) {
   var peg$e105 = peg$otherExpectation("template document");
   var peg$e106 = peg$otherExpectation("template literal");
   var peg$e107 = peg$otherExpectation("template substitution");
-  var peg$e108 = peg$classExpectation(["/", ",", ")", "]", "}", " ", "\t"], true, false);
+  var peg$e108 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false);
   var peg$e109 = peg$otherExpectation("slash-separated path");
   var peg$e110 = peg$classExpectation([["a", "z"]], false, false);
   var peg$e111 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false);
@@ -780,14 +780,16 @@ function peg$parse(input, options) {
     // A single slash is a path key
     return annotate([ops.literal, ""], location());
     };
-  var peg$f110 = function(keys) {
+  var peg$f110 = function(char) { return /\s/.test(char); };
+  var peg$f111 = function(char) { return char; };
+  var peg$f112 = function(keys) {
       return annotate(keys, location());
     };
-  var peg$f111 = function() {
+  var peg$f113 = function() {
       return annotate([markers.global, text()], location());
     };
-  var peg$f112 = function(char) { return /\s/.test(char); };
-  var peg$f113 = function(char) { return char; };
+  var peg$f114 = function(char) { return /\s/.test(char); };
+  var peg$f115 = function(char) { return char; };
   var peg$currPos = options.peg$currPos | 0;
   var peg$savedPos = peg$currPos;
   var peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -6050,15 +6052,44 @@ function peg$parse(input, options) {
   }
 
   function peg$parseuriKeyChar() {
-    var s0;
+    var s0, s1, s2, s3;
 
-    s0 = input.charAt(peg$currPos);
-    if (peg$r10.test(s0)) {
+    s0 = peg$currPos;
+    s1 = input.charAt(peg$currPos);
+    if (peg$r10.test(s1)) {
       peg$currPos++;
     } else {
-      s0 = peg$FAILED;
+      s1 = peg$FAILED;
       if (peg$silentFails === 0) { peg$fail(peg$e108); }
     }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      peg$savedPos = peg$currPos;
+      s3 = peg$f110(s1);
+      if (s3) {
+        s3 = undefined;
+      } else {
+        s3 = peg$FAILED;
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f111(s1);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
     if (s0 === peg$FAILED) {
       s0 = peg$parseescapedChar();
     }
@@ -6086,7 +6117,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f110(s1);
+      s1 = peg$f112(s1);
     }
     s0 = s1;
     peg$silentFails--;
@@ -6137,7 +6168,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f111();
+        s0 = peg$f113();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -6217,7 +6248,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f112(s1);
+      s2 = peg$f114(s1);
       if (s2) {
         s2 = undefined;
       } else {
@@ -6225,7 +6256,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f113(s1);
+        s0 = peg$f115(s1);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;

package/src/compiler/parserHelpers.js

@@ -28,7 +28,7 @@ export const markers = {
  * If a parse result is an object that will be evaluated at runtime, attach the
  * location of the source code that produced it for debugging and error messages.
  *
- * @param {Code[]} code
+ * @param {any[]} code
  * @param {CodeLocation} location
  */
 export function annotate(code, location) {
@@ -375,11 +375,12 @@ export function makePath(keys) {
   const reference = annotate([markers.reference, headKey], head.location);
 
   let code = [markers.traverse, reference, ...tail];
-  code.location = spanLocations(code);
+  const location = spanLocations(code);
+  code = annotate(code, location);
 
   // Last key has trailing slash implies unpack operation
   if (trailingSlash.has(args.at(-1)[1])) {
-    code = annotate([ops.unpack, code], code.location);
+    code = annotate([ops.unpack, code], location);
   }
 
   return code;

package/src/runtime/getHandlers.js

@@ -6,5 +6,5 @@ export default function getHandlers(tree) {
     return null;
   }
   const root = Tree.root(tree);
-  return root.handlers;
+  return /** @type {any} */ (root).handlers;
 }

package/src/runtime/ops.js

@@ -204,7 +204,7 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
 export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
   // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
+  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
@@ -424,7 +424,7 @@ addOpLabel(remainder, "«ops.remainder»");
 export async function rootDirectory(...keys) {
   const tree = new OrigamiFiles("/");
   // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
+  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");

package/test/compiler/codeHelpers.js

@@ -7,6 +7,15 @@ export function assertCodeEqual(actual, expected) {
   assert.deepStrictEqual(actualStripped, expectedStripped);
 }
 
+export function assertCodeLocations(code) {
+  assert(code.location, "no location");
+  for (const item of code) {
+    if (Array.isArray(item)) {
+      assertCodeLocations(item);
+    }
+  }
+}
+
 /**
  * Adds a fake source to code.
  *

package/test/compiler/optimize.test.js

@@ -4,7 +4,11 @@ import * as compile from "../../src/compiler/compile.js";
 import optimize from "../../src/compiler/optimize.js";
 import { markers } from "../../src/compiler/parserHelpers.js";
 import { ops } from "../../src/runtime/internal.js";
-import { assertCodeEqual, createCode } from "./codeHelpers.js";
+import {
+  assertCodeEqual,
+  assertCodeLocations,
+  createCode,
+} from "./codeHelpers.js";
 
 describe("optimize", () => {
   test("change local references to context references", () => {
@@ -277,5 +281,6 @@ function assertCompile(expression, expected, mode = "shell") {
   const globals = new ObjectTree({});
   const fn = compile.expression(expression, { globals, mode, parent });
   const actual = fn.code;
+  assertCodeLocations(actual);
   assertCodeEqual(actual, expected);
 }

package/test/compiler/parse.test.js

@@ -3,7 +3,7 @@ import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
 import { markers } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
-import { assertCodeEqual } from "./codeHelpers.js";
+import { assertCodeEqual, assertCodeLocations } from "./codeHelpers.js";
 
 describe("Origami parser", () => {
   test("additiveExpression", () => {
@@ -1596,16 +1596,8 @@ function assertParse(
   assertCodeEqual(code, expected);
 }
 
-function assertCodeLocations(code) {
-  assert(code.location, "no location");
-  for (const item of code) {
-    if (Array.isArray(item)) {
-      assertCodeLocations(item);
-    }
-  }
-}
-
 function assertThrows(startRule, source, message, position, mode = "shell") {
+  // @ts-ignore We declare this so we can inspect it in debugger
   let code;
   try {
     code = parse(source, {

package/test/runtime/expressionObject.test.js

@@ -54,7 +54,7 @@ describe("expressionObject", () => {
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
     const parent = new ObjectTree({});
-    parent.handlers = {
+    /** @type {any} */ (parent).handlers = {
       "json.handler": {
         unpack: JSON.parse,
       },

package/test/runtime/ops.test.js

@@ -358,7 +358,7 @@ describe("ops", () => {
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope.call(b);
-      assert.equal(await scope.get("c"), 1);
+      assert.equal(await scope?.get("c"), 1);
     });
 
     test("accepts an optional context", async () => {
@@ -372,7 +372,7 @@ describe("ops", () => {
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope.call(b, tree);
-      assert.equal(await scope.get("c"), 1);
+      assert.equal(await scope?.get("c"), 1);
     });
   });