@weborigami/language 0.6.0 → 0.6.2

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectMap, ObjectMap, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -155,16 +155,37 @@ describe("ops", () => {
     assert(ops.greaterThanOrEqual("ab", "aa"));
   });
 
+  test("ops.inOperator returns true if a is in object b", () => {
+    assert.strictEqual(ops.inOperator("a", { a: 1, b: 2 }), true);
+    assert.strictEqual(ops.inOperator("c", { a: 1, b: 2 }), false);
+    const arr = [0, 0, 0];
+    assert.strictEqual(ops.inOperator(1, arr), true);
+    assert.strictEqual(ops.inOperator(3, arr), false);
+  });
+
   test("ops.inherited walks up the object parent chain", async () => {
-    const tree = new DeepObjectMap({
-      a: {
-        b: {},
+    const tree = new ObjectMap(
+      {
+        a: {
+          b: {},
+        },
       },
-    });
+      { deep: true }
+    );
     const b = await Tree.traverse(tree, "a", "b");
     assert.equal(await ops.inherited(2, { object: b }), tree);
   });
 
+  test("ops.instanceOf checks prototype chain", () => {
+    class Parent {}
+    class Child extends Parent {}
+    const child = new Child();
+    assert.strictEqual(ops.instanceOf(child, Child), true);
+    assert.strictEqual(ops.instanceOf(child, Parent), true);
+    assert.strictEqual(ops.instanceOf(child, Object), true);
+    assert.strictEqual(ops.instanceOf(child, Array), false);
+  });
+
   test("ops.lambda defines a function with no inputs", async () => {
     const code = createCode([ops.lambda, [], [ops.literal, "result"]]);
     const fn = await evaluate(code);
@@ -368,12 +389,15 @@ describe("ops", () => {
 
   describe("ops.scope", () => {
     test("returns the scope of the given tree", async () => {
-      const tree = new DeepObjectMap({
-        a: {
-          b: {},
+      const tree = new ObjectMap(
+        {
+          a: {
+            b: {},
+          },
+          c: 1,
         },
-        c: 1,
-      });
+        { deep: true }
+      );
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope(b);

package/test/runtime/jsGlobals.test.js

@@ -1,21 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import jsGlobals from "../../src/project/jsGlobals.js";
-
-describe("jsGlobals", () => {
-  test("wraps static methods to bind them to defining object", async () => {
-    const all = jsGlobals.Promise.all;
-    const value = await all([Promise.resolve("hi")]);
-    assert.equal(value, "hi");
-  });
-
-  test("can invoke a global constructor", async () => {
-    const { Number: fixture } = jsGlobals;
-    // Without `new`
-    const instance1 = fixture(5);
-    assert.equal(instance1, 5);
-    // With `new`
-    const instance = new fixture();
-    assert(instance instanceof Number);
-  });
-});