@weborigami/language 0.6.12 → 0.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "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.12",
+    "@weborigami/async-tree": "0.6.14",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.2"

package/src/compiler/parserHelpers.js

@@ -316,21 +316,21 @@ export function makeLambda(params, body, location) {
  *
  *      {
  *        x = { a: 1 }
- *        ...x
- *        y = x
+ *        ...y
+ *        z = { b: 2}
  *      }
  *
  *  will be treated as:
  *
  *      {
  *        x = { a: 1 }
- *        y = x
- *        _result: {
- *          x
- *          ...x
+ *        z = { b: 2}
+ *        _result: ops.merge(
+ *          { x }
  *          y
- *        }
- *      }.result
+ *          { z }
+ *        )
+ *      }._result
  *
  * @param {*} spreads
  * @param {CodeLocation} location
@@ -338,6 +338,7 @@ export function makeLambda(params, body, location) {
 function makeMerge(spreads, location) {
   const topEntries = [];
   const resultEntries = [];
+
   for (const spread of spreads) {
     if (spread[0] === ops.object) {
       topEntries.push(...spread.slice(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,23 +173,12 @@ export function exponentiation(a, b) {
 addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
- * Flatten the values of the given trees
+ * Flatten the values of the given trees by one level.
  *
  * @param {...any} args
  */
 export async function flat(...args) {
-  const arrays = await Promise.all(
-    args.map(async (arg) => {
-      if (isUnpackable(arg)) {
-        arg = await arg.unpack();
-      }
-      return arg instanceof Array || typeof arg !== "object"
-        ? arg
-        : await Tree.values(arg);
-    }),
-  );
-
-  return arrays.flat();
+  return Tree.flat(args);
 }
 addOpLabel(flat, "«ops.flat»");
 

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,
+      });
     });
   });