quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/index.ts

@@ -1,12 +1,10 @@
 import type {
   QuickJSDeferredPromise,
   QuickJSHandle,
-  QuickJSVm,
-} from "quickjs-emscripten";
-import type {
+  QuickJSContext,
   SuccessOrFail,
   VmCallResult,
-} from "quickjs-emscripten/dist/vm-interface";
+} from "quickjs-emscripten";
 
 import VMMap from "./vmmap";
 import marshal from "./marshal";
@@ -48,13 +46,15 @@ export type Options = {
    * Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the VM.
    */
   registeredObjects?: Iterable<[any, QuickJSHandle | string]>;
+  /** Compatibility with quickjs-emscripten prior to v0.15. Inject code for compatibility into context at Arena class initialization time. */
+  compat?: boolean;
 };
 
 /**
  * The Arena class manages all generated handles at once by quickjs-emscripten and automatically converts objects between the host and the QuickJS VM.
  */
 export class Arena {
-  vm: QuickJSVm;
+  context: QuickJSContext;
   _map: VMMap;
   _registeredMap: VMMap;
   _registeredMapDispose: Set<any> = new Set();
@@ -64,13 +64,21 @@ export class Arena {
   _symbolHandle: QuickJSHandle;
   _options?: Options;
 
-  /** Constructs a new Arena instance. It requires a quickjs-emscripten VM initialized with `quickjs.createVM()`. */
-  constructor(vm: QuickJSVm, options?: Options) {
-    this.vm = vm;
+  /** Constructs a new Arena instance. It requires a quickjs-emscripten context initialized with `quickjs.newContext()`. */
+  constructor(ctx: QuickJSContext, options?: Options) {
+    if (options?.compat && !("runtime" in ctx)) {
+      (ctx as any).runtime = {
+        hasPendingJob: () => (ctx as any).hasPendingJob(),
+        executePendingJobs: (maxJobsToExecute?: number | void) =>
+          (ctx as any).executePendingJobs(maxJobsToExecute),
+      };
+    }
+
+    this.context = ctx;
     this._options = options;
-    this._symbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-    this._map = new VMMap(vm);
-    this._registeredMap = new VMMap(vm);
+    this._symbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+    this._map = new VMMap(ctx);
+    this._registeredMap = new VMMap(ctx);
     this.registerAll(options?.registeredObjects ?? defaultRegisteredObjects);
   }
 
@@ -87,7 +95,7 @@ export class Arena {
    * Evaluate JS code in the VM and get the result as an object on the host side. It also converts and re-throws error objects when an error is thrown during evaluation.
    */
   evalCode<T = any>(code: string): T {
-    const handle = this.vm.evalCode(code);
+    const handle = this.context.evalCode(code);
     return this._unwrapResultAndUnmarshal(handle);
   }
 
@@ -95,7 +103,7 @@ export class Arena {
    * Almost same as `vm.executePendingJobs()`, but it converts and re-throws error objects when an error is thrown during evaluation.
    */
   executePendingJobs(maxJobsToExecute?: number): number {
-    const result = this.vm.executePendingJobs(maxJobsToExecute);
+    const result = this.context.runtime.executePendingJobs(maxJobsToExecute);
     if ("value" in result) {
       return result.value;
     }
@@ -111,7 +119,7 @@ export class Arena {
   expose(obj: { [k: string]: any }) {
     for (const [key, value] of Object.entries(obj)) {
       mayConsume(this._marshal(value), (handle) => {
-        this.vm.setProp(this.vm.global, key, handle);
+        this.context.setProp(this.context.global, key, handle);
       });
     }
   }
@@ -125,7 +133,8 @@ export class Arena {
     const wrapped = this._wrap(target);
     if (typeof wrapped === "undefined") return target;
     walkObject(wrapped, (v) => {
-      this._sync.add(this._unwrap(v));
+      const u = this._unwrap(v);
+      this._sync.add(u);
     });
     return wrapped;
   }
@@ -139,9 +148,9 @@ export class Arena {
     if (this._registeredMap.has(target)) return;
     const handle =
       typeof handleOrCode === "string"
-        ? this._unwrapResult(this.vm.evalCode(handleOrCode))
+        ? this._unwrapResult(this.context.evalCode(handleOrCode))
         : handleOrCode;
-    if (eq(this.vm, handle, this.vm.undefined)) return;
+    if (eq(this.context, handle, this.context.undefined)) return;
     if (typeof handleOrCode === "string") {
       this._registeredMapDispose.add(target);
     }
@@ -179,7 +188,8 @@ export class Arena {
 
   startSync(target: any) {
     if (!isObject(target)) return;
-    this._sync.add(this._unwrap(target));
+    const u = this._unwrap(target);
+    this._sync.add(u);
   }
 
   endSync(target: any) {
@@ -249,7 +259,7 @@ export class Arena {
     }
 
     const handle = marshal(this._wrap(target) ?? target, {
-      vm: this.vm,
+      ctx: this.context,
       unmarshal: this._unmarshal,
       isMarshalable: this._isMarshalable,
       find: this._marshalFind,
@@ -276,7 +286,7 @@ export class Arena {
 
     const [wrappedHandle] = this._wrapHandle(handle);
     return unmarshal(wrappedHandle ?? handle, {
-      vm: this.vm,
+      ctx: this.context,
       marshal: this._marshal,
       find: this._unmarshalFind,
       pre: this._preUnmarshal,
@@ -293,9 +303,11 @@ export class Arena {
       return;
     }
 
-    const wrappedT = this._wrap(t);
+    let wrappedT = this._wrap(t);
     const [wrappedH] = this._wrapHandle(h);
-    if (!wrappedT || !wrappedH) return; // t or h is not an object
+    const isPromise = t instanceof Promise;
+    if (!wrappedH || (!wrappedT && !isPromise)) return; // t or h is not an object
+    if (isPromise) wrappedT = t;
 
     const unwrappedT = this._unwrap(t);
     const [unwrappedH, unwrapped] = this._unwrapHandle(h);
@@ -321,7 +333,7 @@ export class Arena {
 
   _wrap<T>(target: T): Wrapped<T> | undefined {
     return wrap(
-      this.vm,
+      this.context,
       target,
       this._symbol,
       this._symbolHandle,
@@ -336,14 +348,16 @@ export class Arena {
 
   _unwrapIfNotSynced = <T>(target: T): T => {
     const unwrapped = this._unwrap(target);
-    return this._sync.has(unwrapped) ? target : unwrapped;
+    return unwrapped instanceof Promise || !this._sync.has(unwrapped)
+      ? unwrapped
+      : target;
   };
 
   _wrapHandle(
     handle: QuickJSHandle
   ): [Wrapped<QuickJSHandle> | undefined, boolean] {
     return wrapHandle(
-      this.vm,
+      this.context,
       handle,
       this._symbol,
       this._symbolHandle,
@@ -353,6 +367,6 @@ export class Arena {
   }
 
   _unwrapHandle(target: QuickJSHandle): [QuickJSHandle, boolean] {
-    return unwrapHandle(this.vm, target, this._symbolHandle);
+    return unwrapHandle(this.context, target, this._symbolHandle);
   }
 }

package/src/marshal/function.test.ts

@@ -1,33 +1,34 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+
 import { json, eq, call } from "../vmutil";
 import marshalFunction from "./function";
 import { expect, test, vi } from "vitest";
 
 test("normal func", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const marshal = vi.fn((v) => json(vm, v));
+  const marshal = vi.fn((v) => json(ctx, v));
   const unmarshal = vi.fn((v) =>
-    eq(vm, v, vm.global) ? undefined : vm.dump(v)
+    eq(ctx, v, ctx.global) ? undefined : ctx.dump(v)
   );
   const preMarshal = vi.fn((_, a) => a);
   const innerfn = vi.fn((..._args: any[]) => "hoge");
   const fn = (...args: any[]) => innerfn(...args);
 
-  const handle = marshalFunction(vm, fn, marshal, unmarshal, preMarshal);
+  const handle = marshalFunction(ctx, fn, marshal, unmarshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
   expect(marshal.mock.calls).toEqual([["length"], [0], ["name"], ["fn"]]); // fn.length, fn.name
   expect(preMarshal.mock.calls).toEqual([[fn, handle]]); // fn.length, fn.name
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(0);
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("fn");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(0);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("fn");
 
-  const result = vm.unwrapResult(
-    vm.callFunction(handle, vm.undefined, vm.newNumber(1), vm.true)
+  const result = ctx.unwrapResult(
+    ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), ctx.true)
   );
 
-  expect(vm.dump(result)).toBe("hoge");
+  expect(ctx.dump(result)).toBe("hoge");
   expect(innerfn).toBeCalledWith(1, true);
   expect(marshal).toHaveBeenLastCalledWith("hoge");
   expect(unmarshal).toBeCalledTimes(3);
@@ -36,48 +37,48 @@ test("normal func", async () => {
   expect(unmarshal.mock.results[2].value).toBe(true);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("func which has properties", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = vi.fn((v) => json(vm, v));
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v) => json(ctx, v));
 
   const fn = () => {};
   fn.hoge = "foo";
 
   const handle = marshalFunction(
-    vm,
+    ctx,
     fn,
     marshal,
-    (v) => vm.dump(v),
+    (v) => ctx.dump(v),
     (_, a) => a
   );
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("function");
-  expect(vm.dump(vm.getProp(handle, "hoge"))).toBe("foo");
+  expect(ctx.typeof(handle)).toBe("function");
+  expect(ctx.dump(ctx.getProp(handle, "hoge"))).toBe("foo");
   expect(marshal).toBeCalledWith("foo");
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const disposables: QuickJSHandle[] = [];
   const marshal = (v: any) => {
-    if (typeof v === "string") return vm.newString(v);
-    if (typeof v === "number") return vm.newNumber(v);
+    if (typeof v === "string") return ctx.newString(v);
+    if (typeof v === "number") return ctx.newNumber(v);
     if (typeof v === "object") {
-      const obj = vm.newObject();
+      const obj = ctx.newObject();
       disposables.push(obj);
       return obj;
     }
-    return vm.null;
+    return ctx.null;
   };
-  const unmarshal = (v: QuickJSHandle) => vm.dump(v);
+  const unmarshal = (v: QuickJSHandle) => ctx.dump(v);
 
   class A {
     a: number;
@@ -87,47 +88,49 @@ test("class", async () => {
     }
   }
 
-  const handle = marshalFunction(vm, A, marshal, unmarshal, (_, a) => a);
+  const handle = marshalFunction(ctx, A, marshal, unmarshal, (_, a) => a);
   if (!handle) throw new Error("handle is undefined");
 
-  const newA = vm.unwrapResult(vm.evalCode(`A => new A(100)`));
-  const instance = vm.unwrapResult(vm.callFunction(newA, vm.undefined, handle));
+  const newA = ctx.unwrapResult(ctx.evalCode(`A => new A(100)`));
+  const instance = ctx.unwrapResult(
+    ctx.callFunction(newA, ctx.undefined, handle)
+  );
 
-  expect(vm.dump(vm.getProp(handle, "name"))).toBe("A");
-  expect(vm.dump(vm.getProp(handle, "length"))).toBe(1);
+  expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("A");
+  expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
   expect(
-    vm.dump(
-      call(vm, "(cls, i) => i instanceof cls", undefined, handle, instance)
+    ctx.dump(
+      call(ctx, "(cls, i) => i instanceof cls", undefined, handle, instance)
     )
   ).toBe(true);
-  expect(vm.dump(vm.getProp(instance, "a"))).toBe(100);
+  expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
 
   disposables.forEach((d) => d.dispose());
   instance.dispose();
   newA.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("preApply", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const marshal = (v: any) => {
-    if (typeof v === "string") return vm.newString(v);
-    if (typeof v === "number") return vm.newNumber(v);
-    return vm.null;
+    if (typeof v === "string") return ctx.newString(v);
+    if (typeof v === "number") return ctx.newNumber(v);
+    return ctx.null;
   };
   const unmarshal = (v: QuickJSHandle) =>
-    vm.typeof(v) === "object" ? that : vm.dump(v);
+    ctx.typeof(v) === "object" ? that : ctx.dump(v);
   const preApply = vi.fn(
     (a: Function, b: any, c: any[]) => a.apply(b, c) + "!"
   );
   const that = {};
-  const thatHandle = vm.newObject();
+  const thatHandle = ctx.newObject();
 
   const fn = () => "foo";
   const handle = marshalFunction(
-    vm,
+    ctx,
     fn,
     marshal,
     unmarshal,
@@ -138,31 +141,36 @@ test("preApply", async () => {
 
   expect(preApply).toBeCalledTimes(0);
 
-  const res = vm.unwrapResult(
-    vm.callFunction(handle, thatHandle, vm.newNumber(100), vm.newString("hoge"))
+  const res = ctx.unwrapResult(
+    ctx.callFunction(
+      handle,
+      thatHandle,
+      ctx.newNumber(100),
+      ctx.newString("hoge")
+    )
   );
 
   expect(preApply).toBeCalledTimes(1);
   expect(preApply).toBeCalledWith(fn, that, [100, "hoge"]);
-  expect(vm.dump(res)).toBe("foo!");
+  expect(ctx.dump(res)).toBe("foo!");
 
   thatHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const f = vi.fn();
 
-  expect(marshalFunction(vm, undefined, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, null, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, false, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, true, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, 1, f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, [1], f, f, f)).toBe(undefined);
-  expect(marshalFunction(vm, { a: 1 }, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, undefined, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, null, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, false, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, true, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, 1, f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, [1], f, f, f)).toBe(undefined);
+  expect(marshalFunction(ctx, { a: 1 }, f, f, f)).toBe(undefined);
   expect(f).toBeCalledTimes(0);
 
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/function.ts

@@ -1,10 +1,11 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { isES2015Class, isObject } from "../util";
 import { call } from "../vmutil";
 import marshalProperties from "./properties";
 
 export default function marshalFunction(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => unknown,
@@ -16,7 +17,7 @@ export default function marshalFunction(
 ): QuickJSHandle | undefined {
   if (typeof target !== "function") return;
 
-  const raw = vm
+  const raw = ctx
     .newFunction(target.name, function (...argHandles) {
       const that = unmarshal(this);
       const args = argHandles.map((a) => unmarshal(a));
@@ -25,7 +26,7 @@ export default function marshalFunction(
         // Class constructors cannot be invoked without new expression, and new.target is not changed
         const result = new target(...args);
         Object.entries(result).forEach(([key, value]) => {
-          vm.setProp(this, key, marshal(value));
+          ctx.setProp(this, key, marshal(value));
         });
         return this;
       }
@@ -37,7 +38,7 @@ export default function marshalFunction(
     .consume((handle2) =>
       // fucntions created by vm.newFunction are not callable as a class constrcutor
       call(
-        vm,
+        ctx,
         `Cls => {
           const fn = function(...args) { return Cls.apply(this, args); };
           fn.name = Cls.name;
@@ -50,7 +51,7 @@ export default function marshalFunction(
     );
 
   const handle = preMarshal(target, raw) ?? raw;
-  marshalProperties(vm, target, raw, marshal);
+  marshalProperties(ctx, target, raw, marshal);
 
   return handle;
 }