run npm install to generate a package lock

node_modules/@weborigami/language/test/runtime/expressionObject.test.js

@@ -0,0 +1,76 @@
+import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+
+import expressionObject from "../../src/runtime/expressionObject.js";
+import { ops } from "../../src/runtime/internal.js";
+
+describe("expressionObject", () => {
+  test("can instantiate an object", async () => {
+    const scope = new ObjectTree({
+      upper: (s) => s.toUpperCase(),
+    });
+
+    const entries = [
+      ["hello", [[ops.scope, "upper"], "hello"]],
+      ["world", [[ops.scope, "upper"], "world"]],
+    ];
+
+    const object = await expressionObject(entries, scope);
+    assert.equal(await object.hello, "HELLO");
+    assert.equal(await object.world, "WORLD");
+    assert.equal(object[symbols.parent], scope);
+  });
+
+  test("can define a property getter", async () => {
+    let count = 0;
+    const increment = () => count++;
+    const entries = [["count", [ops.getter, [increment]]]];
+    const object = await expressionObject(entries, null);
+    assert.equal(await object.count, 0);
+    assert.equal(await object.count, 1);
+  });
+
+  test("treats a getter for a primitive value as a regular property", async () => {
+    const entries = [["name", [ops.getter, "world"]]];
+    const object = await expressionObject(entries, null);
+    assert.equal(object.name, "world");
+  });
+
+  test("can instantiate an Origami tree", async () => {
+    const entries = [
+      ["name", "world"],
+      ["message", [ops.concat, "Hello, ", [ops.scope, "name"], "!"]],
+    ];
+    const parent = new ObjectTree({});
+    const object = await expressionObject(entries, parent);
+    assert.deepEqual(await Tree.plain(object), {
+      name: "world",
+      message: "Hello, world!",
+    });
+    assert.equal(object[symbols.parent], parent);
+  });
+
+  test("returned object values can be unpacked", async () => {
+    const entries = [["data.json", `{ "a": 1 }`]];
+    const parent = new ObjectTree({
+      "json.handler": {
+        unpack: JSON.parse,
+      },
+    });
+    const result = await expressionObject(entries, parent);
+    const dataJson = await result["data.json"];
+    const json = await dataJson.unpack();
+    assert.deepEqual(json, { a: 1 });
+  });
+
+  test("a key declared with parentheses is not enumerable", async () => {
+    const entries = [
+      ["(hidden)", "shh"],
+      ["visible", "hey"],
+    ];
+    const object = await expressionObject(entries, null);
+    assert.deepEqual(Object.keys(object), ["visible"]);
+    assert.equal(object["hidden"], "shh");
+  });
+});