@weborigami/language 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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.1",
-    "@weborigami/types": "0.3.1",
+    "@weborigami/async-tree": "0.3.2",
+    "@weborigami/types": "0.3.2",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/runtime/expressionObject.js

@@ -1,6 +1,7 @@
 import {
   extension,
   ObjectTree,
+  setParent,
   symbols,
   trailingSlash,
   Tree,
@@ -116,12 +117,7 @@ export default async function expressionObject(entries, parent) {
   });
 
   // Attach the parent
-  Object.defineProperty(object, symbols.parent, {
-    configurable: true,
-    enumerable: false,
-    value: parent,
-    writable: true,
-  });
+  setParent(object, parent);
 
   // Evaluate any properties that were declared as immediate: get their value
   // and overwrite the property getter with the actual value.

package/src/runtime/handlers.js

@@ -5,7 +5,7 @@ import {
   isStringLike,
   isUnpackable,
   scope,
-  symbols,
+  setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
 
@@ -92,7 +92,7 @@ export async function handleExtension(parent, value, key) {
         if (handler.mediaType) {
           value.mediaType = handler.mediaType;
         }
-        value[symbols.parent] = parent;
+        setParent(value, parent);
 
         const unpack = handler.unpack;
         if (unpack) {

package/src/runtime/ops.js

@@ -11,7 +11,7 @@ import {
   deepText,
   isUnpackable,
   scope as scopeFn,
-  symbols,
+  setParent,
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
@@ -131,7 +131,7 @@ export async function document(frontData, bodyCode) {
     ...frontData,
     "@text": body,
   };
-  object[symbols.parent] = this;
+  setParent(object, this);
   return object;
 }
 addOpLabel(document, "«ops.document");
@@ -224,7 +224,8 @@ export async function inherited(key) {
     return undefined;
   }
   const parentScope = scopeFn(this.parent);
-  return parentScope.get(key);
+  const value = await parentScope.get(key);
+  return value;
 }
 addOpLabel(inherited, "«ops.inherited»");
 
@@ -388,17 +389,33 @@ export async function merge(...codes) {
     return directObject;
   }
 
-  // Second pass: evaluate the trees with the direct properties object in scope
-  let context;
-  if (directObject) {
-    context = Tree.from(directObject);
-    context.parent = this;
-  } else {
-    context = this;
-  }
-
+  // If we have direct property entries, create a context for them. The
+  // `expressionObject` function will set the object's parent symbol to `this`.
+  // Tree.from will call the ObjectTree constructor, which will use that symbol
+  // to set the parent for the new tree to `this`.
+  const context = directObject ? Tree.from(directObject) : this;
+
+  // Second pass: evaluate the trees. For the trees which are direct property
+  // entries, we'll copy over the values we've already calculated. We can't
+  // reuse the `directObject` as is because in a merge we need to respect the
+  // order in which the properties are defined. Trees that aren't direct
+  // property entries are evaluated with the direct property entries in scope.
   const trees = await Promise.all(
-    codes.map(async (code) => evaluate.call(context, code))
+    codes.map(async (code) => {
+      if (code[0] === object) {
+        // Using the code as reference, create a new object with the direct
+        // property values we've already calculated.
+        const object = {};
+        for (const [key] of code.slice(1)) {
+          // @ts-ignore directObject will always be defined
+          object[key] = directObject[key];
+        }
+        setParent(object, this);
+        return object;
+      } else {
+        return evaluate.call(context, code);
+      }
+    })
   );
 
   return mergeTrees.call(this, ...trees);