quickjs-emscripten-sync 1.0.0 → 1.3.0

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 vm = (await getQuickJS()).createVm();
+  const prototypeCheck = vm.unwrapResult(
+    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  );
+
+  const obj = {};
+  const preMarshal = vi.fn((_, a) => a);
+
+  const handle = marshalJSON(vm, obj, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  expect(vm.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))
+    )
+  ).toBe(true);
+
+  handle.dispose();
+  prototypeCheck.dispose();
+  vm.dispose();
+});
+
+test("normal object", async () => {
+  const vm = (await getQuickJS()).createVm();
+  const prototypeCheck = vm.unwrapResult(
+    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  );
+  const entries = vm.unwrapResult(vm.evalCode(`Object.entries`));
+
+  const obj = { a: 100, b: "hoge" };
+  const preMarshal = vi.fn((_, a) => a);
+
+  const handle = marshalJSON(vm, 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(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))
+    )
+  ).toBe(true);
+  const e = vm.unwrapResult(vm.callFunction(entries, vm.undefined, handle));
+  expect(vm.dump(e)).toEqual([
+    ["a", 100],
+    ["b", "hoge"],
+  ]);
+
+  e.dispose();
+  handle.dispose();
+  prototypeCheck.dispose();
+  entries.dispose();
+  vm.dispose();
+});
+
+test("array", async () => {
+  const vm = (await getQuickJS()).createVm();
+  const isArray = vm.unwrapResult(vm.evalCode(`Array.isArray`));
+
+  const array = [1, "aa"];
+  const preMarshal = vi.fn((_, a) => a);
+
+  const handle = marshalJSON(vm, 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(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)))
+  ).toBe(true);
+
+  handle.dispose();
+  isArray.dispose();
+  vm.dispose();
+});

package/src/marshal/json.ts

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

package/src/marshal/object.test.ts

@@ -1,4 +1,6 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { call } from "../vmutil";
 import marshalObject from "./object";
 
@@ -9,8 +11,8 @@ test("empty object", async () => {
   );
 
   const obj = {};
-  const marshal = jest.fn();
-  const preMarshal = jest.fn((_, a) => a);
+  const marshal = vi.fn();
+  const preMarshal = vi.fn((_, a) => a);
 
   const handle = marshalObject(vm, obj, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
@@ -39,14 +41,14 @@ test("normal object", async () => {
   const entries = vm.unwrapResult(vm.evalCode(`Object.entries`));
 
   const obj = { a: 100, b: "hoge" };
-  const marshal = jest.fn(v =>
+  const marshal = vi.fn((v) =>
     typeof v === "number"
       ? vm.newNumber(v)
       : typeof v === "string"
       ? vm.newString(v)
       : vm.null
   );
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
   const handle = marshalObject(vm, obj, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
@@ -76,20 +78,61 @@ test("normal object", async () => {
   vm.dispose();
 });
 
+test("array", async () => {
+  const vm = (await getQuickJS()).createVm();
+  const isArray = vm.unwrapResult(vm.evalCode(`Array.isArray`));
+
+  const array = [1, "aa"];
+  const marshal = vi.fn((v) =>
+    typeof v === "number"
+      ? vm.newNumber(v)
+      : typeof v === "string"
+      ? vm.newString(v)
+      : vm.null
+  );
+  const preMarshal = vi.fn((_, a) => a);
+
+  const handle = marshalObject(vm, array, marshal, 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(marshal.mock.calls).toEqual([
+    ["0"],
+    [1],
+    ["1"],
+    ["aa"],
+    ["length"],
+    [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)))
+  ).toBe(true);
+
+  handle.dispose();
+  isArray.dispose();
+  vm.dispose();
+});
+
 test("prototype", async () => {
   const vm = (await getQuickJS()).createVm();
 
   const proto = { a: 100 };
   const protoHandle = vm.newObject();
   vm.setProp(protoHandle, "a", vm.newNumber(100));
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
   const obj = Object.create(proto);
   obj.b = "hoge";
   const handle = marshalObject(
     vm,
     obj,
-    v =>
+    (v) =>
       v === proto
         ? protoHandle
         : typeof v === "string"

package/src/marshal/object.ts

@@ -13,13 +13,13 @@ export default function marshalObject(
 ): QuickJSHandle | undefined {
   if (typeof target !== "object" || target === null) return;
 
-  const raw = vm.newObject();
+  const raw = Array.isArray(target) ? vm.newArray() : vm.newObject();
   const handle = preMarshal(target, raw) ?? raw;
 
   // prototype
   const prototype = Object.getPrototypeOf(target);
   const prototypeHandle =
-    prototype && prototype !== Object.prototype
+    prototype && prototype !== Object.prototype && prototype !== Array.prototype
       ? marshal(prototype)
       : undefined;
   if (prototypeHandle) {

package/src/marshal/primitive.test.ts

@@ -1,4 +1,6 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import { eq } from "../vmutil";
 import marshalPrimitive from "./primitive";
 

package/src/marshal/primitive.ts

@@ -16,10 +16,16 @@ export default function marshalPrimitive(
       return target ? vm.true : vm.false;
     case "object":
       return target === null ? vm.null : undefined;
+
     // BigInt is not supported by quickjs-emscripten
     // case "bigint":
-    //   return call(vm, `s => BigInt(s)`, undefined, vm.newString(target.toString()));
+    //   return call(
+    //     vm,
+    //     `s => BigInt(s)`,
+    //     undefined,
+    //     vm.newString(target.toString())
+    //   );
   }
-  // symbol is not supported yet
+
   return undefined;
 }

package/src/marshal/promise.test.ts

@@ -0,0 +1,86 @@
+import {
+  getQuickJS,
+  type Disposable,
+  type QuickJSDeferredPromise,
+  type QuickJSHandle,
+} from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+import { newDeferred } from "../util";
+
+import { fn, json } from "../vmutil";
+import marshalPromise from "./promise";
+
+const testPromise = (reject: boolean) => async () => {
+  const vm = (await getQuickJS()).createVm();
+
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn((v) => {
+    const handle = json(vm, v);
+    disposables.push(handle);
+    return handle;
+  });
+  const preMarshal = vi.fn(
+    (_: any, a: QuickJSDeferredPromise): QuickJSHandle => {
+      disposables.push(a);
+      return a.handle;
+    }
+  );
+
+  const mockNotify = vi.fn();
+  const notify = vm.newFunction("notify", (handle1, handle2) => {
+    const arg1 = vm.dump(handle1);
+    const arg2 = vm.dump(handle2);
+    mockNotify(arg1, arg2);
+  });
+  disposables.push(notify);
+
+  const notifier = fn(
+    vm,
+    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`
+  );
+  disposables.push(notifier);
+
+  const deferred = newDeferred();
+  if (reject) {
+    deferred.promise.catch(() => {});
+  }
+  const handle = marshalPromise(vm, deferred.promise, marshal, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  expect(marshal).toBeCalledTimes(0);
+  expect(preMarshal).toBeCalledTimes(1);
+  expect(preMarshal.mock.calls[0][0]).toBe(deferred.promise);
+  expect(preMarshal.mock.calls[0][1].handle).toBe(handle);
+
+  notifier(undefined, notify, handle);
+
+  expect(mockNotify).toBeCalledTimes(0);
+  expect(deferred.resolve).not.toBeUndefined();
+  expect(vm.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject("hoge");
+  } else {
+    deferred.resolve("hoge");
+  }
+
+  expect(vm.hasPendingJob()).toBe(false);
+  if (reject) {
+    await expect(deferred.promise).rejects.toBe("hoge");
+  } else {
+    await expect(deferred.promise).resolves.toBe("hoge");
+  }
+  expect(vm.hasPendingJob()).toBe(true);
+  const executed = vm.unwrapResult(vm.executePendingJobs());
+  expect(executed).toBe(1);
+  expect(mockNotify).toBeCalledTimes(1);
+  expect(mockNotify).toBeCalledWith(reject ? "rejected" : "resolved", "hoge");
+  expect(marshal).toBeCalledTimes(1);
+  expect(marshal.mock.calls).toEqual([["hoge"]]);
+
+  disposables.forEach((h) => h.dispose());
+  vm.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/marshal/promise.ts

@@ -0,0 +1,26 @@
+import type {
+  QuickJSDeferredPromise,
+  QuickJSHandle,
+  QuickJSVm,
+} from "quickjs-emscripten";
+
+export default function marshalPromise(
+  vm: QuickJSVm,
+  target: unknown,
+  marshal: (target: unknown) => QuickJSHandle,
+  preMarshal: (
+    target: unknown,
+    handle: QuickJSDeferredPromise
+  ) => QuickJSHandle | undefined
+) {
+  if (!(target instanceof Promise)) return;
+
+  const promise = vm.newPromise();
+
+  target.then(
+    (d) => promise.resolve(marshal(d)),
+    (d) => promise.reject(marshal(d))
+  );
+
+  return preMarshal(target, promise) ?? promise.handle;
+}

package/src/marshal/properties.test.ts

@@ -1,5 +1,7 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
-import { send } from "../vmutil";
+import { expect, test, vi } from "vitest";
+
+import { json } from "../vmutil";
 import marshalProperties from "./properties";
 
 test("works", async () => {
@@ -20,8 +22,8 @@ test("works", async () => {
   );
 
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn(t => {
-    if (typeof t !== "function") return send(vm, t);
+  const marshal = vi.fn((t) => {
+    if (typeof t !== "function") return json(vm, t);
     const fn = vm.newFunction("", () => {});
     disposables.push(fn);
     return fn;
@@ -65,7 +67,7 @@ test("works", async () => {
   vm.unwrapResult(vm.callFunction(descTester, vm.undefined, handle, expected));
 
   expected.dispose();
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
   descTester.dispose();
   vm.dispose();
@@ -73,7 +75,7 @@ test("works", async () => {
 
 test("empty", async () => {
   const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn();
+  const marshal = vi.fn();
   const handle = vm.newObject();
   const obj = {};
 

package/src/marshal/properties.ts

@@ -17,7 +17,7 @@ export default function marshalProperties(
     const setHandle =
       typeof desc.set === "undefined" ? undefined : marshal(desc.set);
 
-    vm.newObject().consume(descObj => {
+    vm.newObject().consume((descObj) => {
       Object.entries(desc).forEach(([k, v]) => {
         const v2 =
           k === "value"
@@ -39,7 +39,7 @@ export default function marshalProperties(
 
   const desc = Object.getOwnPropertyDescriptors(target);
   Object.entries(desc).forEach(([k, v]) => cb(k, v));
-  Object.getOwnPropertySymbols(desc).forEach(k => cb(k, (desc as any)[k]));
+  Object.getOwnPropertySymbols(desc).forEach((k) => cb(k, (desc as any)[k]));
 
   call(vm, `Object.defineProperties`, undefined, handle, descs).dispose();
 

package/src/marshal/symbol.test.ts

@@ -1,9 +1,11 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import marshalSymbol from "./symbol";
 
 test("works", async () => {
   const vm = (await getQuickJS()).createVm();
-  const pre = jest.fn();
+  const pre = vi.fn();
   const sym = Symbol("foobar");
 
   expect(marshalSymbol(vm, {}, pre)).toBe(undefined);

package/src/unmarshal/function.test.ts

@@ -1,15 +1,17 @@
 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] => [
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(vm, v), false]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.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);
@@ -39,14 +41,17 @@ test("function", async () => {
   const vm = (await getQuickJS()).createVm();
   const that = { a: 1 };
   const thatHandle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
-  const marshal = jest.fn(v => (v === that ? thatHandle : send(vm, v)));
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    v === that ? thatHandle : json(vm, v),
+    false,
+  ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.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; })`)
@@ -70,7 +75,7 @@ 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();
@@ -79,15 +84,16 @@ test("function", async () => {
 test("constructor", async () => {
   const vm = (await getQuickJS()).createVm();
   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 marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? vm.undefined : json(vm, v),
+    false,
+  ]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.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; })`)
@@ -119,23 +125,24 @@ 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();
 });
 
 test("class", async () => {
   const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(v =>
-    typeof v === "object" ? vm.undefined : send(vm, v)
-  );
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? vm.undefined : json(vm, v),
+    false,
+  ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     const ty = vm.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
     return [vm.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; } })`)
@@ -167,14 +174,14 @@ 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();
 });
 
 test("undefined", async () => {
   const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
+  const f = vi.fn();
 
   expect(unmarshalFunction(vm, vm.undefined, f, f, f)).toEqual(undefined);
   expect(unmarshalFunction(vm, vm.true, f, f, f)).toEqual(undefined);

package/src/unmarshal/function.ts

@@ -1,40 +1,48 @@
 import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-import { call } from "../vmutil";
+import { call, mayConsumeAll } from "../vmutil";
 import unmarshalProperties from "./properties";
 
 export default function unmarshalFunction(
   vm: QuickJSVm,
   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));
+  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(
+              vm,
+              `(Cls, ...args) => new Cls(...args)`,
+              thisHandle,
+              handle,
+              ...argHandles
+            )
+          );
+          Object.defineProperties(
+            this,
+            Object.getOwnPropertyDescriptors(instance)
+          );
+          return this;
+        }
 
-    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)
+        );
 
-    const resultHandle = vm.unwrapResult(
-      vm.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;