quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/unmarshal/function.test.ts

@@ -1,18 +1,20 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
-import { send } from "../vmutil";
+import { expect, test, vi } from "vitest";
+
+import { json } from "../vmutil";
 import unmarshalFunction from "./function";
 
 test("arrow function", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(v => send(vm, v));
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(ctx, v), false]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`(a, b) => a + b`));
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`(a, b) => a + b`));
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func(1, 2)).toBe(3);
@@ -32,27 +34,30 @@ test("arrow function", async () => {
   handle.dispose();
   expect(() => func(1, 2)).toThrow("Lifetime not alive");
 
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("function", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const that = { a: 1 };
-  const thatHandle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
-  const marshal = jest.fn(v => (v === that ? thatHandle : send(vm, v)));
+  const thatHandle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    v === that ? thatHandle : json(ctx, v),
+    false,
+  ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (a) { return this.a + a; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (a) { return this.a + a; })`)
   );
 
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func.call(that, 2)).toBe(3);
@@ -70,31 +75,32 @@ test("function", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(func, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   thatHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("constructor", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn(v =>
-    typeof v === "object" ? vm.undefined : send(vm, v)
-  );
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
+    false,
+  ]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (b) { this.a = b + 2; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function (b) { this.a = b + 2; })`)
   );
 
   const Cls = unmarshalFunction(
-    vm,
+    ctx,
     handle,
     marshal,
     unmarshal,
@@ -119,30 +125,31 @@ test("constructor", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(v =>
-    typeof v === "object" ? vm.undefined : send(vm, v)
-  );
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
+    false,
+  ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
   );
 
   const Cls = unmarshalFunction(
-    vm,
+    ctx,
     handle,
     marshal,
     unmarshal,
@@ -167,32 +174,34 @@ test("class", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
-
-  expect(unmarshalFunction(vm, vm.undefined, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.true, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.false, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.null, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.newString("hoge"), f, f, f)).toEqual(
+  const ctx = (await getQuickJS()).newContext();
+  const f = vi.fn();
+
+  expect(unmarshalFunction(ctx, ctx.undefined, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.true, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.false, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.null, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.newString("hoge"), f, f, f)).toEqual(
+    undefined
+  );
+  expect(unmarshalFunction(ctx, ctx.newNumber(-10), f, f, f)).toEqual(
     undefined
   );
-  expect(unmarshalFunction(vm, vm.newNumber(-10), f, f, f)).toEqual(undefined);
 
-  const obj = vm.newObject();
-  expect(unmarshalFunction(vm, obj, f, f, f)).toEqual(undefined);
-  const array = vm.newArray();
-  expect(unmarshalFunction(vm, array, f, f, f)).toEqual(undefined);
+  const obj = ctx.newObject();
+  expect(unmarshalFunction(ctx, obj, f, f, f)).toEqual(undefined);
+  const array = ctx.newArray();
+  expect(unmarshalFunction(ctx, array, f, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   obj.dispose();
   array.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/function.ts

@@ -1,44 +1,53 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-import { call } from "../vmutil";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { call, mayConsumeAll } from "../vmutil";
 import unmarshalProperties from "./properties";
 
 export default function unmarshalFunction(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
-  marshal: (value: unknown) => QuickJSHandle,
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
+  marshal: (value: unknown) => [QuickJSHandle, boolean],
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): Function | undefined {
-  if (vm.typeof(handle) !== "function") return;
-
-  const raw = function(this: any, ...args: any[]) {
-    const thisHandle = marshal(this);
-    const argHandles = args.map(a => marshal(a));
-
-    if (new.target) {
-      const [instance] = unmarshal(
-        call(
-          vm,
-          `(Cls, ...args) => new Cls(...args)`,
-          thisHandle,
-          handle,
-          ...argHandles
-        )
-      );
-      Object.defineProperties(this, Object.getOwnPropertyDescriptors(instance));
-      return this;
-    }
-
-    const resultHandle = vm.unwrapResult(
-      vm.callFunction(handle, thisHandle, ...argHandles)
+  if (ctx.typeof(handle) !== "function") return;
+
+  const raw = function (this: any, ...args: any[]) {
+    return mayConsumeAll(
+      [marshal(this), ...args.map((a) => marshal(a))],
+      (thisHandle, ...argHandles) => {
+        if (new.target) {
+          const [instance] = unmarshal(
+            call(
+              ctx,
+              `(Cls, ...args) => new Cls(...args)`,
+              thisHandle,
+              handle,
+              ...argHandles
+            )
+          );
+          Object.defineProperties(
+            this,
+            Object.getOwnPropertyDescriptors(instance)
+          );
+          return this;
+        }
+
+        const resultHandle = ctx.unwrapResult(
+          ctx.callFunction(handle, thisHandle, ...argHandles)
+        );
+
+        const [result, alreadyExists] = unmarshal(resultHandle);
+        if (alreadyExists) resultHandle.dispose();
+
+        return result;
+      }
     );
-    const [result, alreadyExists] = unmarshal(resultHandle);
-    if (alreadyExists) resultHandle.dispose();
-    return result;
   };
 
   const func = preUnmarshal(raw, handle) ?? raw;
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return func;
 }

package/src/unmarshal/index.test.ts

@@ -1,19 +1,15 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import VMMap from "../vmmap";
 import unmarshal from ".";
+import { json } from "../vmutil";
 
 test("primitive, array, object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(() => vm.undefined);
-  const map = new VMMap(vm);
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       foo: 1,
       aaa: [1, true, {}],
@@ -21,7 +17,7 @@ test("primitive, array, object", async () => {
       bbb: () => "bar"
     })`)
   );
-  const target = unmarshal(handle, { vm, pre, find, marshal });
+  const target = unmarshal(handle);
 
   expect(target).toEqual({
     hoge: "foo",
@@ -32,119 +28,91 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
-  vm.getProp(handle, "aaa").consume(h =>
-    expect(map.getByHandle(h)).toBe(target.aaa)
-  );
-  vm.getProp(handle, "aaa")
-    .consume(h => vm.getProp(h, 2))
-    .consume(h => expect(map.getByHandle(h)).toBe(target.aaa[2]));
-  vm.getProp(handle, "nested").consume(h =>
-    expect(map.getByHandle(h)).toBe(target.nested)
-  );
-  vm.getProp(handle, "bbb").consume(h =>
-    expect(map.getByHandle(h)).toBe(target.bbb)
-  );
+  ctx
+    .getProp(handle, "aaa")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa));
+  ctx
+    .getProp(handle, "aaa")
+    .consume((h) => ctx.getProp(h, 2))
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa[2]));
+  ctx
+    .getProp(handle, "nested")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.nested));
+  ctx
+    .getProp(handle, "bbb")
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.bbb));
 
   expect(marshal).toBeCalledTimes(0);
   expect(target.bbb()).toBe("bar");
   expect(marshal).toBeCalledTimes(1);
   expect(marshal).toBeCalledWith(target); // thisArg of target.bbb()
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
 test("object with symbol key", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
-  const pre = (t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  };
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       [Symbol("a")]: "bar"
     })`)
   );
-  const target = unmarshal(handle, {
-    vm,
-    pre,
-    find: () => undefined,
-    marshal: () => vm.undefined,
-  });
+  const target = unmarshal(handle);
 
   expect(target.hoge).toBe("foo");
   expect(target[Object.getOwnPropertySymbols(target)[0]]).toBe("bar");
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
-test("func", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t: unknown) => {
-    const h =
-      t === undefined
-        ? vm.undefined
-        : vm.unwrapResult(
-            vm.callFunction(
-              jsonParse,
-              vm.undefined,
-              vm.newString(JSON.stringify(t))
-            )
-          );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return h;
-  });
+test("function", async () => {
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function(a) { return a.a + "!"; })`)
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`(function(a) { return a.a + "!"; })`)
   );
-  const map = new VMMap(vm);
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const func = unmarshal(handle, { vm, find, pre, marshal });
+  const func = unmarshal(handle);
   const arg = { a: "hoge" };
   expect(func(arg)).toBe("hoge!");
   expect(marshal).toBeCalledTimes(2);
   expect(marshal).toBeCalledWith(undefined); // this
   expect(marshal).toBeCalledWith(arg); // arg
-  expect(map.size).toBe(2);
+  expect(map.size).toBe(3);
   expect(map.getByHandle(handle)).toBe(func);
+  expect(map.has(func)).toBe(true);
   expect(map.has(func.prototype)).toBe(true);
+  expect(map.has(arg)).toBe(true);
 
-  map.dispose();
-  disposables.forEach(d => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
+});
+
+test("promise", async () => {
+  const { ctx, unmarshal, dispose } = await setup();
+
+  const deferred = ctx.newPromise();
+  const promise = unmarshal(deferred.handle);
+  deferred.resolve(ctx.newString("resolved!"));
+  ctx.runtime.executePendingJobs();
+  await expect(promise).resolves.toBe("resolved!");
+
+  const deferred2 = ctx.newPromise();
+  const promise2 = unmarshal(deferred2.handle);
+  deferred2.reject(ctx.newString("rejected!"));
+  ctx.runtime.executePendingJobs();
+  await expect(promise2).rejects.toBe("rejected!");
+
+  deferred.dispose();
+  deferred2.dispose();
+  dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const map = new VMMap(vm);
-  const marshal = jest.fn((t: unknown) => {
-    const h = vm.unwrapResult(
-      vm.callFunction(jsonParse, vm.undefined, vm.newString(JSON.stringify(t)))
-    );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return h;
-  });
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       class Cls {
         static hoge = "foo";
 
@@ -157,12 +125,7 @@ test("class", async () => {
       Cls
     }`)
   );
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const Cls = unmarshal(handle, { vm, find, pre, marshal });
+  const Cls = unmarshal(handle);
 
   expect(Cls.hoge).toBe("foo");
   expect(Cls.foo instanceof Cls).toBe(true);
@@ -172,8 +135,46 @@ test("class", async () => {
   expect(cls.foo).toBe(4);
 
   handle.dispose();
-  map.dispose();
-  disposables.forEach(d => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
 });
+
+const setup = async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const map = new VMMap(ctx);
+  const disposables: QuickJSHandle[] = [];
+  const marshal = vi.fn((target: unknown): [QuickJSHandle, boolean] => {
+    const handle = map.get(target);
+    if (handle) return [handle, false];
+
+    const handle2 =
+      typeof target === "function"
+        ? ctx.newFunction(target.name, (...handles) => {
+            target(...handles.map((h) => ctx.dump(h)));
+          })
+        : json(ctx, target);
+    const ty = ctx.typeof(handle2);
+    if (ty === "object" || ty === "function") map.set(target, handle2);
+    return [handle2, false];
+  });
+
+  return {
+    ctx,
+    map,
+    unmarshal: (handle: QuickJSHandle) =>
+      unmarshal(handle, {
+        find: (h) => map.getByHandle(h),
+        marshal,
+        pre: (t, h) => {
+          map.set(t, h);
+          return t;
+        },
+        ctx: ctx,
+      }),
+    marshal,
+    dispose: () => {
+      disposables.forEach((d) => d.dispose());
+      map.dispose();
+      ctx.dispose();
+    },
+  };
+};

package/src/unmarshal/index.ts

@@ -1,14 +1,17 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import unmarshalFunction from "./function";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
+import unmarshalPromise from "./promise";
 import unmarshalSymbol from "./symbol";
 
 export type Options = {
-  vm: QuickJSVm;
-  marshal: (target: unknown) => QuickJSHandle;
+  ctx: QuickJSContext;
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
+  marshal: (target: unknown) => [QuickJSHandle, boolean];
   find: (handle: QuickJSHandle) => unknown | undefined;
-  pre: <T>(target: T, handle: QuickJSHandle) => T | undefined;
+  pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -20,10 +23,10 @@ function unmarshalInner(
   handle: QuickJSHandle,
   options: Options
 ): [any, boolean] {
-  const { vm, marshal, find, pre } = options;
+  const { ctx, marshal, find, pre } = options;
 
   {
-    const [target, ok] = unmarshalPrimitive(vm, handle);
+    const [target, ok] = unmarshalPrimitive(ctx, handle);
     if (ok) return [target, false];
   }
 
@@ -37,9 +40,10 @@ function unmarshalInner(
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
   const result =
-    unmarshalSymbol(vm, handle, pre) ??
-    unmarshalFunction(vm, handle, marshal, unmarshal2, pre) ??
-    unmarshalObject(vm, handle, unmarshal2, pre);
+    unmarshalSymbol(ctx, handle, pre) ??
+    unmarshalPromise(ctx, handle, marshal, pre) ??
+    unmarshalFunction(ctx, handle, marshal, unmarshal2, pre) ??
+    unmarshalObject(ctx, handle, unmarshal2, pre);
 
   return [result, false];
 }