quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/marshal/index.test.ts

@@ -7,7 +7,7 @@ import marshal from ".";
 import { newDeferred } from "../util";
 
 test("primitive, array, object", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   const target = {
     hoge: "foo",
@@ -17,7 +17,7 @@ test("primitive, array, object", async () => {
   };
   const handle = marshal(target);
 
-  expect(vm.dump(handle)).toEqual(target);
+  expect(ctx.dump(handle)).toEqual(target);
   expect(map.size).toBe(4);
   expect(map.get(target)).toBe(handle);
   expect(map.has(target.aaa)).toBe(true);
@@ -28,17 +28,17 @@ test("primitive, array, object", async () => {
 });
 
 test("object with symbol key", async () => {
-  const { vm, marshal, dispose } = await setup();
+  const { ctx, marshal, dispose } = await setup();
 
   const target = {
     foo: "hoge",
     [Symbol("a")]: 1,
   };
   const handle = marshal(target);
-  expect(vm.dump(call(vm, `a => a.foo`, undefined, handle))).toBe("hoge");
+  expect(ctx.dump(call(ctx, `a => a.foo`, undefined, handle))).toBe("hoge");
   expect(
-    vm.dump(
-      call(vm, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle)
+    ctx.dump(
+      call(ctx, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle)
     )
   ).toBe(1);
 
@@ -46,19 +46,19 @@ test("object with symbol key", async () => {
 });
 
 test("arrow function", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
   const hoge = () => "foo";
   hoge.foo = { bar: 1 };
   const handle = marshal(hoge);
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(0);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("hoge");
-  const foo = vm.getProp(handle, "foo");
-  expect(vm.dump(foo)).toEqual({ bar: 1 });
-  expect(vm.dump(vm.unwrapResult(vm.callFunction(handle, vm.undefined)))).toBe(
-    "foo"
-  );
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(0);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("hoge");
+  const foo = ctx.getProp(handle, "foo");
+  expect(ctx.dump(foo)).toEqual({ bar: 1 });
+  expect(
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined)))
+  ).toBe("foo");
   expect(map.size).toBe(2);
   expect(map.get(hoge)).toBe(handle);
   expect(map.has(hoge.foo)).toBe(true);
@@ -68,24 +68,26 @@ test("arrow function", async () => {
 });
 
 test("function", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   const bar = function (a: number, b: { hoge: number }) {
     return a + b.hoge;
   };
   const handle = marshal(bar);
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("bar");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("bar");
   expect(map.size).toBe(2);
   expect(map.get(bar)).toBe(handle);
   expect(map.has(bar.prototype)).toBe(true);
 
-  const b = vm.unwrapResult(vm.evalCode(`({ hoge: 2 })`));
+  const b = ctx.unwrapResult(ctx.evalCode(`({ hoge: 2 })`));
   expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(handle, vm.undefined, vm.newNumber(1), b))
+    ctx.dump(
+      ctx.unwrapResult(
+        ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), b)
+      )
     )
   ).toBe(3);
 
@@ -94,18 +96,20 @@ test("function", async () => {
 });
 
 test("promise", async () => {
-  const { vm, marshal, dispose } = await setup();
+  const { ctx, marshal, dispose } = await setup();
   const register = fn(
-    vm,
+    ctx,
     `promise => { promise.then(d => notify("resolve", d), d => notify("reject", d)); }`
   );
 
   let notified: any;
-  vm.newFunction("notify", (...handles) => {
-    notified = handles.map((h) => vm.dump(h));
-  }).consume((h) => {
-    vm.setProp(vm.global, "notify", h);
-  });
+  ctx
+    .newFunction("notify", (...handles) => {
+      notified = handles.map((h) => ctx.dump(h));
+    })
+    .consume((h) => {
+      ctx.setProp(ctx.global, "notify", h);
+    });
 
   const deferred = newDeferred();
   const handle = marshal(deferred.promise);
@@ -113,7 +117,7 @@ test("promise", async () => {
 
   deferred.resolve("foo");
   await deferred.promise;
-  expect(vm.unwrapResult(vm.executePendingJobs())).toBe(1);
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
   expect(notified).toEqual(["resolve", "foo"]);
 
   const deferred2 = newDeferred();
@@ -122,7 +126,7 @@ test("promise", async () => {
 
   deferred2.reject("bar");
   await expect(deferred2.promise).rejects.toBe("bar");
-  expect(vm.unwrapResult(vm.executePendingJobs())).toBe(1);
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
   expect(notified).toEqual(["reject", "bar"]);
 
   register.dispose();
@@ -130,7 +134,7 @@ test("promise", async () => {
 });
 
 test("class", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   class A {
     a: number;
@@ -172,34 +176,38 @@ test("class", async () => {
     map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.set)
   ).toBe(true);
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(1);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("_A");
-  const staticA = vm.getProp(handle, "a");
-  expect(instanceOf(vm, staticA, handle)).toBe(true);
-  expect(vm.dump(vm.getProp(staticA, "a"))).toBe(100);
-  expect(vm.dump(vm.getProp(staticA, "b"))).toBe("a!");
-
-  const newA = vm.unwrapResult(vm.evalCode(`A => new A("foo")`));
-  const instance = vm.unwrapResult(vm.callFunction(newA, vm.undefined, handle));
-  expect(instanceOf(vm, instance, handle)).toBe(true);
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100);
-  expect(vm.dump(vm.getProp(instance, "b"))).toBe("foo!");
-  const methodHoge = vm.getProp(instance, "hoge");
-  expect(vm.dump(vm.unwrapResult(vm.callFunction(methodHoge, instance)))).toBe(
-    101
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("_A");
+  const staticA = ctx.getProp(handle, "a");
+  expect(instanceOf(ctx, staticA, handle)).toBe(true);
+  expect(ctx.dump(ctx.getProp(staticA, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(staticA, "b"))).toBe("a!");
+
+  const newA = ctx.unwrapResult(ctx.evalCode(`A => new A("foo")`));
+  const instance = ctx.unwrapResult(
+    ctx.callFunction(newA, ctx.undefined, handle)
   );
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100); // not synced
+  expect(instanceOf(ctx, instance, handle)).toBe(true);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!");
+  const methodHoge = ctx.getProp(instance, "hoge");
+  expect(
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(methodHoge, instance)))
+  ).toBe(101);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100); // not synced
 
-  const getter = vm.unwrapResult(vm.evalCode(`a => a.foo`));
-  const setter = vm.unwrapResult(vm.evalCode(`(a, b) => a.foo = b`));
+  const getter = ctx.unwrapResult(ctx.evalCode(`a => a.foo`));
+  const setter = ctx.unwrapResult(ctx.evalCode(`(a, b) => a.foo = b`));
   expect(
-    vm.dump(vm.unwrapResult(vm.callFunction(getter, vm.undefined, instance)))
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(getter, ctx.undefined, instance))
+    )
   ).toBe("foo!");
-  vm.unwrapResult(
-    vm.callFunction(setter, vm.undefined, instance, vm.newString("b"))
+  ctx.unwrapResult(
+    ctx.callFunction(setter, ctx.undefined, instance, ctx.newString("b"))
   );
-  expect(vm.dump(vm.getProp(instance, "b"))).toBe("foo!"); // not synced
+  expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!"); // not synced
 
   staticA.dispose();
   newA.dispose();
@@ -213,13 +221,13 @@ test("class", async () => {
 
 test("marshalable", async () => {
   const isMarshalable = vi.fn((a: any) => a !== globalThis);
-  const { vm, marshal, dispose } = await setup({
+  const { ctx, marshal, dispose } = await setup({
     isMarshalable,
   });
 
   const handle = marshal({ a: globalThis, b: 1 });
 
-  expect(vm.dump(handle)).toEqual({ a: undefined, b: 1 });
+  expect(ctx.dump(handle)).toEqual({ a: undefined, b: 1 });
   expect(isMarshalable).toBeCalledWith(globalThis);
   expect(isMarshalable).toReturnWith(false);
 
@@ -228,7 +236,7 @@ test("marshalable", async () => {
 
 test("marshalable json", async () => {
   const isMarshalable = vi.fn(() => "json" as const);
-  const { vm, marshal, dispose } = await setup({
+  const { ctx, marshal, dispose } = await setup({
     isMarshalable,
   });
 
@@ -239,7 +247,7 @@ test("marshalable json", async () => {
   };
   const handle = marshal(target);
 
-  expect(vm.dump(handle)).toEqual({
+  expect(ctx.dump(handle)).toEqual({
     a: { d: target.a.d.toISOString(), e: [null, 1, {}] },
     b: 1,
   });
@@ -255,15 +263,15 @@ const setup = async ({
 }: {
   isMarshalable?: (target: any) => boolean | "json";
 } = {}) => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
+  const ctx = (await getQuickJS()).newContext();
+  const map = new VMMap(ctx);
   return {
-    vm,
+    ctx,
     map,
     marshal: (v: any) =>
       marshal(v, {
-        vm,
-        unmarshal: (h) => map.getByHandle(h) ?? vm.dump(h),
+        ctx: ctx,
+        unmarshal: (h) => map.getByHandle(h) ?? ctx.dump(h),
         isMarshalable,
         pre: (t, d) => {
           const h = handleFrom(d);
@@ -274,7 +282,7 @@ const setup = async ({
       }),
     dispose: () => {
       map.dispose();
-      vm.dispose();
+      ctx.dispose();
     },
   };
 };

package/src/marshal/index.ts

@@ -1,8 +1,9 @@
 import type {
   QuickJSDeferredPromise,
   QuickJSHandle,
-  QuickJSVm,
+  QuickJSContext,
 } from "quickjs-emscripten";
+
 import marshalFunction from "./function";
 import marshalObject from "./object";
 import marshalPrimitive from "./primitive";
@@ -11,7 +12,7 @@ import marshalJSON from "./json";
 import marshalPromise from "./promise";
 
 export type Options = {
-  vm: QuickJSVm;
+  ctx: QuickJSContext;
   unmarshal: (handle: QuickJSHandle) => unknown;
   isMarshalable?: (target: unknown) => boolean | "json";
   find: (target: unknown) => QuickJSHandle | undefined;
@@ -24,10 +25,10 @@ export type Options = {
 };
 
 export function marshal(target: unknown, options: Options): QuickJSHandle {
-  const { vm, unmarshal, isMarshalable, find, pre } = options;
+  const { ctx, unmarshal, isMarshalable, find, pre } = options;
 
   {
-    const primitive = marshalPrimitive(vm, target);
+    const primitive = marshalPrimitive(ctx, target);
     if (primitive) {
       return primitive;
     }
@@ -40,22 +41,22 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
 
   const marshalable = isMarshalable?.(target);
   if (marshalable === false) {
-    return vm.undefined;
+    return ctx.undefined;
   }
 
   const pre2 = (target: any, handle: QuickJSHandle | QuickJSDeferredPromise) =>
     pre(target, handle, marshalable);
   if (marshalable === "json") {
-    return marshalJSON(vm, target, pre2);
+    return marshalJSON(ctx, target, pre2);
   }
 
   const marshal2 = (t: unknown) => marshal(t, options);
   return (
-    marshalSymbol(vm, target, pre2) ??
-    marshalPromise(vm, target, marshal2, pre2) ??
-    marshalFunction(vm, target, marshal2, unmarshal, pre2, options.preApply) ??
-    marshalObject(vm, target, marshal2, pre2) ??
-    vm.undefined
+    marshalSymbol(ctx, target, pre2) ??
+    marshalPromise(ctx, target, marshal2, pre2) ??
+    marshalFunction(ctx, target, marshal2, unmarshal, pre2, options.preApply) ??
+    marshalObject(ctx, target, marshal2, pre2) ??
+    ctx.undefined
   );
 }
 

package/src/marshal/json.test.ts

@@ -4,58 +4,58 @@ import { expect, test, vi } from "vitest";
 import marshalJSON from "./json";
 
 test("empty object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
   );
 
   const obj = {};
   const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, obj, preMarshal);
+  const handle = marshalJSON(ctx, obj, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
+  expect(ctx.typeof(handle)).toBe("object");
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
   expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
     )
   ).toBe(true);
 
   handle.dispose();
   prototypeCheck.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
   );
-  const entries = vm.unwrapResult(vm.evalCode(`Object.entries`));
+  const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
 
   const obj = { a: 100, b: "hoge" };
   const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, obj, preMarshal);
+  const handle = marshalJSON(ctx, obj, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, "a"))).toBe(100);
-  expect(vm.getString(vm.getProp(handle, "b"))).toBe("hoge");
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, "a"))).toBe(100);
+  expect(ctx.getString(ctx.getProp(handle, "b"))).toBe("hoge");
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
   expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
     )
   ).toBe(true);
-  const e = vm.unwrapResult(vm.callFunction(entries, vm.undefined, handle));
-  expect(vm.dump(e)).toEqual([
+  const e = ctx.unwrapResult(ctx.callFunction(entries, ctx.undefined, handle));
+  expect(ctx.dump(e)).toEqual([
     ["a", 100],
     ["b", "hoge"],
   ]);
@@ -64,31 +64,31 @@ test("normal object", async () => {
   handle.dispose();
   prototypeCheck.dispose();
   entries.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const isArray = vm.unwrapResult(vm.evalCode(`Array.isArray`));
+  const ctx = (await getQuickJS()).newContext();
+  const isArray = ctx.unwrapResult(ctx.evalCode(`Array.isArray`));
 
   const array = [1, "aa"];
   const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalJSON(vm, array, preMarshal);
+  const handle = marshalJSON(ctx, array, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, 0))).toBe(1);
-  expect(vm.getString(vm.getProp(handle, 1))).toBe("aa");
-  expect(vm.getNumber(vm.getProp(handle, "length"))).toBe(2);
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, 0))).toBe(1);
+  expect(ctx.getString(ctx.getProp(handle, 1))).toBe("aa");
+  expect(ctx.getNumber(ctx.getProp(handle, "length"))).toBe(2);
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(array);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
   expect(
-    vm.dump(vm.unwrapResult(vm.callFunction(isArray, vm.undefined, handle)))
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))
   ).toBe(true);
 
   handle.dispose();
   isArray.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/json.ts

@@ -1,15 +1,16 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { json } from "../vmutil";
 
 export default function marshalJSON(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   preMarshal: (
     target: unknown,
     handle: QuickJSHandle
   ) => QuickJSHandle | undefined
 ): QuickJSHandle {
-  const raw = json(vm, target);
+  const raw = json(ctx, target);
   const handle = preMarshal(target, raw) ?? raw;
   return handle;
 }