@weborigami/language 0.6.13 → 0.6.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.13",
+    "@weborigami/async-tree": "0.6.15",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.2"

package/src/runtime/WatchFilesMixin.d.ts

@@ -1,7 +1,8 @@
 import { Mixin } from "../../index.ts";
 
 declare const WatchFilesMixin: Mixin<{
-  watch(): Promise<void>;
+  unwatch(): void;
+  watch(): void;
 }>;
 
 export default WatchFilesMixin;

package/src/runtime/WatchFilesMixin.js

@@ -27,7 +27,7 @@ export default function WatchFilesMixin(Base) {
       this.dispatchEvent(new TreeEvent("change", { filePath }));
     }
 
-    async unwatch() {
+    unwatch() {
       if (!this.watching) {
         return;
       }
@@ -37,7 +37,7 @@ export default function WatchFilesMixin(Base) {
     }
 
     // Turn on watching for the directory.
-    async watch() {
+    watch() {
       if (this.watching) {
         return;
       }

package/src/runtime/explainTraverseError.js

@@ -27,8 +27,9 @@ export default async function explainTraverseError(error) {
   }
 
   // The key that caused the error is the one before the current position
-  const path = pathFromKeys(keys.slice(0, position));
-  let message = `The path traversal ended unexpectedly at: ${path}`;
+  const path = pathFromKeys(keys);
+  const problemKey = keys[position - 1];
+  let message = `Tried to traverse path:  ${path}\nStopped unexpectedly at: ${problemKey}`;
 
   const key = trailingSlash.remove(keys[position - 1]);
 

package/src/runtime/handleExtension.js

@@ -57,7 +57,7 @@ export default async function handleExtension(value, key, parent = null) {
       }
     }
   }
-  value;
+
   return value;
 }
 

package/src/runtime/mergeTrees.js

@@ -1,4 +1,10 @@
-import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
+import {
+  isPlainObject,
+  isUnpackable,
+  symbols,
+  trailingSlash,
+  Tree,
+} from "@weborigami/async-tree";
 import assignPropertyDescriptors from "./assignPropertyDescriptors.js";
 
 /**
@@ -28,11 +34,48 @@ export default async function mergeTrees(...trees) {
 
   // If all trees are plain objects, return a plain object.
   if (unpacked.every((tree) => isPlainObject(tree) && !Tree.isMap(tree))) {
-    // Use our Object.assign variation that avoids invoking property getters.
-    return assignPropertyDescriptors({}, ...unpacked);
+    return mergePlainObjects(...unpacked);
   }
 
   // Merge the trees.
   const result = Tree.merge(...unpacked);
   return result;
 }
+
+// Return the merged keys for the given objects, respecting any keys method on
+// objects that were created using Origami object literals. This preserves
+// trailing slashes.
+function mergeObjectKeys(objects) {
+  const mergedKeys = new Set();
+  for (const obj of objects) {
+    const objectKeys =
+      typeof obj[symbols.keys] === "function"
+        ? obj[symbols.keys]()
+        : Object.keys(obj);
+    for (const key of objectKeys) {
+      const alternateKey = trailingSlash.toggle(key);
+      if (mergedKeys.has(alternateKey)) {
+        // The new key differs from a key from an earlier object key only by the
+        // presence or absence of a trailing slash. Replace that old key.
+        mergedKeys.delete(alternateKey);
+      }
+      mergedKeys.add(key);
+    }
+  }
+  return Array.from(mergedKeys);
+}
+
+function mergePlainObjects(...objects) {
+  // Use our Object.assign variation that avoids invoking property getters.
+  const result = assignPropertyDescriptors({}, ...objects);
+
+  // Attach a keys method
+  Object.defineProperty(result, symbols.keys, {
+    configurable: true,
+    enumerable: false,
+    value: () => mergeObjectKeys(objects),
+    writable: true,
+  });
+
+  return result;
+}

package/src/runtime/ops.js

@@ -173,12 +173,12 @@ export function exponentiation(a, b) {
 addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
- * Flatten the values of the given trees to a depth of 1
+ * Flatten the values of the given trees by one level.
  *
  * @param {...any} args
  */
 export async function flat(...args) {
-  return Tree.flat(args, 2); // add 1 to account for the array of arguments
+  return Tree.flat(args);
 }
 addOpLabel(flat, "«ops.flat»");
 

package/test/runtime/errors.test.js

@@ -210,7 +210,8 @@ evaluating: \x1B[31mrepeat\x1B[0m`,
       await assertError(
         `a/b/sup/c`,
         `TraverseError: A path hit a null or undefined value.
-The path traversal ended unexpectedly at: a/b/sup/
+Tried to traverse path:  a/b/sup/c
+Stopped unexpectedly at: sup/
 Perhaps you intended: sub/
 evaluating: \x1B[31msup/\x1B[0m`,
         { parent },
@@ -224,7 +225,8 @@ evaluating: \x1B[31msup/\x1B[0m`,
       await assertError(
         `map/1/a`,
         `TraverseError: A path hit a null or undefined value.
-The path traversal ended unexpectedly at: map/1/
+Tried to traverse path:  map/1/a
+Stopped unexpectedly at: 1/
 Slash-separated keys are searched as strings. Here there's no string "1" key, but there is a number 1 key.
 To get the value for that number key, use parentheses: map/(1)
 evaluating: \x1B[31m1/\x1B[0m`,
@@ -239,7 +241,8 @@ evaluating: \x1B[31m1/\x1B[0m`,
       await assertError(
         `file.foo/bar`,
         `TraverseError: A path hit binary file data that can't be unpacked.
-The path traversal ended unexpectedly at: file.foo/
+Tried to traverse path:  file.foo/bar
+Stopped unexpectedly at: file.foo/
 The value couldn't be unpacked because no file extension handler is registered for ".foo".
 evaluating: \x1B[31mfile.foo/\x1B[0m`,
         { parent },
@@ -255,7 +258,8 @@ evaluating: \x1B[31mfile.foo/\x1B[0m`,
       await assertError(
         `a/b/`,
         `TraverseError: A path tried to unpack data that's already unpacked.
-The path traversal ended unexpectedly at: a/b/
+Tried to traverse path:  a/b/
+Stopped unexpectedly at: b/
 You can drop the trailing slash and just use: b
 evaluating: \x1B[31mb/\x1B[0m`,
         { parent },
@@ -269,7 +273,8 @@ evaluating: \x1B[31mb/\x1B[0m`,
       await assertError(
         `a/b/`,
         `TraverseError: A path tried to unpack a value that doesn't exist.
-The path traversal ended unexpectedly at: a/b/
+Tried to traverse path:  a/b/
+Stopped unexpectedly at: b/
 evaluating: \x1B[31mb/\x1B[0m`,
         { parent },
       );

package/test/runtime/mergeTrees.test.js

@@ -1,4 +1,4 @@
-import { ObjectMap, Tree } from "@weborigami/async-tree";
+import { ObjectMap, symbols, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
@@ -23,7 +23,7 @@ describe("mergeTrees", () => {
           calledBar = true;
           return true;
         },
-      }
+      },
     );
 
     // Shouldn't call functions when just getting keys
@@ -40,6 +40,22 @@ describe("mergeTrees", () => {
     });
   });
 
+  test("respects trailing slashes in keys", async () => {
+    const result = await mergeTrees(
+      {
+        "a/": 1, // key will be overwritten
+        b: 2, // key will be overwritten
+        c: 3,
+      },
+      {
+        a: 4,
+        "b/": 5,
+      },
+    );
+    const keys = result[symbols.keys]();
+    assert.deepEqual(keys, ["c", "a", "b/"]);
+  });
+
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees(
       new ObjectMap({
@@ -49,7 +65,7 @@ describe("mergeTrees", () => {
       {
         b: 3,
         c: 4,
-      }
+      },
     );
     assert.deepEqual(await Tree.plain(tree), {
       a: 1,

package/test/runtime/ops.test.js

@@ -159,7 +159,14 @@ describe("ops", () => {
       });
       const array = [5, 6];
       const result = await ops.flat(object, tree, array);
-      assert.deepEqual(result, [1, 2, 3, 4, 5, 6]);
+      assert.deepEqual(await Tree.plain(result), {
+        a: 1,
+        b: 2,
+        c: 3,
+        d: 4,
+        0: 5,
+        1: 6,
+      });
     });
   });