quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/marshal/index.test.ts

@@ -1,10 +1,13 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import VMMap from "../vmmap";
-import { instanceOf, call } from "../vmutil";
+import { instanceOf, call, handleFrom, fn } from "../vmutil";
 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",
@@ -14,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);
@@ -25,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);
 
@@ -43,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);
@@ -65,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 }) {
+  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);
 
@@ -90,8 +95,46 @@ test("function", async () => {
   dispose();
 });
 
+test("promise", async () => {
+  const { ctx, marshal, dispose } = await setup();
+  const register = fn(
+    ctx,
+    `promise => { promise.then(d => notify("resolve", d), d => notify("reject", d)); }`
+  );
+
+  let notified: any;
+  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);
+  register(undefined, handle);
+
+  deferred.resolve("foo");
+  await deferred.promise;
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
+  expect(notified).toEqual(["resolve", "foo"]);
+
+  const deferred2 = newDeferred();
+  const handle2 = marshal(deferred2.promise);
+  register(undefined, handle2);
+
+  deferred2.reject("bar");
+  await expect(deferred2.promise).rejects.toBe("bar");
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
+  expect(notified).toEqual(["reject", "bar"]);
+
+  register.dispose();
+  dispose();
+});
+
 test("class", async () => {
-  const { vm, map, marshal, dispose } = await setup();
+  const { ctx, map, marshal, dispose } = await setup();
 
   class A {
     a: number;
@@ -117,6 +160,7 @@ test("class", async () => {
     }
   }
 
+  expect(A.name).toBe("_A"); // class A's name is _A in vitest
   const handle = marshal(A);
   if (!map) throw new Error("map is undefined");
 
@@ -126,40 +170,44 @@ test("class", async () => {
   expect(map.has(A.a)).toBe(true);
   expect(map.has(A.prototype.hoge)).toBe(true);
   expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")!.get)
+    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.get)
   ).toBe(true);
   expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")!.set)
+    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();
@@ -172,44 +220,69 @@ test("class", async () => {
 });
 
 test("marshalable", async () => {
-  const isMarshalable = jest.fn((a: any) => a !== globalThis);
-  const { vm, marshal, dispose } = await setup({
+  const isMarshalable = vi.fn((a: any) => a !== globalThis);
+  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);
 
   dispose();
 });
 
+test("marshalable json", async () => {
+  const isMarshalable = vi.fn(() => "json" as const);
+  const { ctx, marshal, dispose } = await setup({
+    isMarshalable,
+  });
+
+  class Hoge {}
+  const target = {
+    a: { c: () => 1, d: new Date(), e: [() => 1, 1, new Hoge()] },
+    b: 1,
+  };
+  const handle = marshal(target);
+
+  expect(ctx.dump(handle)).toEqual({
+    a: { d: target.a.d.toISOString(), e: [null, 1, {}] },
+    b: 1,
+  });
+  expect(isMarshalable).toBeCalledTimes(1);
+  expect(isMarshalable).toBeCalledWith(target);
+  expect(isMarshalable).toReturnWith("json");
+
+  dispose();
+});
+
 const setup = async ({
   isMarshalable,
 }: {
-  isMarshalable?: (target: any) => boolean;
+  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, h) => {
+        pre: (t, d) => {
+          const h = handleFrom(d);
           map.set(t, h);
           return h;
         },
-        find: t => map.get(t),
+        find: (t) => map.get(t),
       }),
     dispose: () => {
       map.dispose();
-      vm.dispose();
+      ctx.dispose();
     },
   };
 };

package/src/marshal/index.ts

@@ -1,23 +1,34 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
+import type {
+  QuickJSDeferredPromise,
+  QuickJSHandle,
+  QuickJSContext,
+} from "quickjs-emscripten";
+
 import marshalFunction from "./function";
 import marshalObject from "./object";
 import marshalPrimitive from "./primitive";
 import marshalSymbol from "./symbol";
+import marshalJSON from "./json";
+import marshalPromise from "./promise";
 
 export type Options = {
-  vm: QuickJSVm;
+  ctx: QuickJSContext;
   unmarshal: (handle: QuickJSHandle) => unknown;
-  isMarshalable?: (target: unknown) => boolean;
+  isMarshalable?: (target: unknown) => boolean | "json";
   find: (target: unknown) => QuickJSHandle | undefined;
-  pre: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined;
+  pre: (
+    target: unknown,
+    handle: QuickJSHandle | QuickJSDeferredPromise,
+    mode: true | "json" | undefined
+  ) => QuickJSHandle | undefined;
   preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
 };
 
 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;
     }
@@ -28,19 +39,25 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
     if (handle) return handle;
   }
 
-  if (isMarshalable?.(target) === false) {
-    return vm.undefined;
+  const marshalable = isMarshalable?.(target);
+  if (marshalable === false) {
+    return ctx.undefined;
   }
 
-  const marshal2 = (t: unknown) => marshal(t, options);
-
-  const result =
-    marshalSymbol(vm, target, pre) ??
-    marshalFunction(vm, target, marshal2, unmarshal, pre, options.preApply) ??
-    marshalObject(vm, target, marshal2, pre) ??
-    vm.undefined;
+  const pre2 = (target: any, handle: QuickJSHandle | QuickJSDeferredPromise) =>
+    pre(target, handle, marshalable);
+  if (marshalable === "json") {
+    return marshalJSON(ctx, target, pre2);
+  }
 
-  return result;
+  const marshal2 = (t: unknown) => marshal(t, options);
+  return (
+    marshalSymbol(ctx, target, pre2) ??
+    marshalPromise(ctx, target, marshal2, pre2) ??
+    marshalFunction(ctx, target, marshal2, unmarshal, pre2, options.preApply) ??
+    marshalObject(ctx, target, marshal2, pre2) ??
+    ctx.undefined
+  );
 }
 
 export default marshal;

package/src/marshal/json.test.ts

@@ -0,0 +1,94 @@
+import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import marshalJSON from "./json";
+
+test("empty object", async () => {
+  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(ctx, obj, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  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(
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
+    )
+  ).toBe(true);
+
+  handle.dispose();
+  prototypeCheck.dispose();
+  ctx.dispose();
+});
+
+test("normal object", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  );
+  const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
+
+  const obj = { a: 100, b: "hoge" };
+  const preMarshal = vi.fn((_, a) => a);
+
+  const handle = marshalJSON(ctx, obj, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  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(
+    ctx.dump(
+      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
+    )
+  ).toBe(true);
+  const e = ctx.unwrapResult(ctx.callFunction(entries, ctx.undefined, handle));
+  expect(ctx.dump(e)).toEqual([
+    ["a", 100],
+    ["b", "hoge"],
+  ]);
+
+  e.dispose();
+  handle.dispose();
+  prototypeCheck.dispose();
+  entries.dispose();
+  ctx.dispose();
+});
+
+test("array", async () => {
+  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(ctx, array, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  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(
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))
+  ).toBe(true);
+
+  handle.dispose();
+  isArray.dispose();
+  ctx.dispose();
+});

package/src/marshal/json.ts

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