quickjs-emscripten-sync 1.2.0 → 1.5.0

package/src/vmutil.test.ts

@@ -1,5 +1,8 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import {
+  fn,
   call,
   consumeAll,
   eq,
@@ -8,183 +11,205 @@ import {
   json,
   mayConsume,
   mayConsumeAll,
+  handleFrom,
 } from "./vmutil";
 
+test("fn", async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const f = fn(ctx, "(a, b) => a + b");
+  expect(ctx.getNumber(f(undefined, ctx.newNumber(1), ctx.newNumber(2)))).toBe(3);
+
+  const obj = ctx.newObject();
+  ctx.setProp(obj, "a", ctx.newNumber(2));
+  const f2 = fn(ctx, "(function() { return this.a + 1; })");
+  expect(ctx.getNumber(f2(obj))).toBe(3);
+
+  obj.dispose();
+  expect(f.alive).toBe(true);
+  expect(f2.alive).toBe(true);
+  f2.dispose();
+  f.dispose();
+  expect(f.alive).toBe(false);
+  expect(f2.alive).toBe(false);
+  ctx.dispose();
+});
+
 test("call", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   expect(
-    vm.getNumber(
-      call(vm, "(a, b) => a + b", undefined, vm.newNumber(1), vm.newNumber(2))
-    )
+    ctx.getNumber(call(ctx, "(a, b) => a + b", undefined, ctx.newNumber(1), ctx.newNumber(2))),
   ).toBe(3);
 
-  const obj = vm.newObject();
-  vm.setProp(obj, "a", vm.newNumber(2));
-  expect(
-    vm.getNumber(call(vm, "(function() { return this.a + 1; })", obj))
-  ).toBe(3);
+  const obj = ctx.newObject();
+  ctx.setProp(obj, "a", ctx.newNumber(2));
+  expect(ctx.getNumber(call(ctx, "(function() { return this.a + 1; })", obj))).toBe(3);
 
   obj.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("eq", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const math1 = vm.unwrapResult(vm.evalCode("Math"));
-  const math2 = vm.unwrapResult(vm.evalCode("Math"));
-  const obj = vm.newObject();
+  const math1 = ctx.unwrapResult(ctx.evalCode("Math"));
+  const math2 = ctx.unwrapResult(ctx.evalCode("Math"));
+  const obj = ctx.newObject();
   expect(math1 === math2).toBe(false);
-  expect(eq(vm, math1, math2)).toBe(true);
-  expect(eq(vm, math1, obj)).toBe(false);
+  expect(eq(ctx, math1, math2)).toBe(true);
+  expect(eq(ctx, math1, obj)).toBe(false);
 
   math1.dispose();
   math2.dispose();
   obj.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("instanceOf", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const pr = vm.unwrapResult(vm.evalCode("Promise"));
-  const func = vm.unwrapResult(vm.evalCode("(function() {})"));
-  const p = vm.unwrapResult(vm.evalCode("Promise.resolve()"));
-  expect(instanceOf(vm, p, pr)).toBe(true);
-  expect(instanceOf(vm, p, func)).toBe(false);
+  const pr = ctx.unwrapResult(ctx.evalCode("Promise"));
+  const func = ctx.unwrapResult(ctx.evalCode("(function() {})"));
+  const p = ctx.unwrapResult(ctx.evalCode("Promise.resolve()"));
+  expect(instanceOf(ctx, p, pr)).toBe(true);
+  expect(instanceOf(ctx, p, func)).toBe(false);
 
   p.dispose();
   pr.dispose();
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("isHandleObject", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
-
-  const obj = vm.newObject();
-  expect(isHandleObject(vm, obj)).toBe(true);
-  const func = vm.newFunction("", () => {});
-  expect(isHandleObject(vm, func)).toBe(true);
-  const array = vm.newArray();
-  expect(isHandleObject(vm, array)).toBe(true);
-  const num = vm.newNumber(NaN);
-  expect(isHandleObject(vm, num)).toBe(false);
+  const ctx = (await getQuickJS()).newContext();
+
+  const obj = ctx.newObject();
+  expect(isHandleObject(ctx, obj)).toBe(true);
+  const func = ctx.newFunction("", () => {});
+  expect(isHandleObject(ctx, func)).toBe(true);
+  const array = ctx.newArray();
+  expect(isHandleObject(ctx, array)).toBe(true);
+  const num = ctx.newNumber(NaN);
+  expect(isHandleObject(ctx, num)).toBe(false);
 
   obj.dispose();
   func.dispose();
   array.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("json", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const handle = json(vm, {
+  const handle = json(ctx, {
     hoge: { foo: ["bar"] },
   });
-  expect(
-    vm.dump(call(vm, `a => a.hoge.foo[0] === "bar"`, undefined, handle))
-  ).toBe(true);
-  expect(vm.typeof(json(vm, undefined))).toBe("undefined");
+  expect(ctx.dump(call(ctx, `a => a.hoge.foo[0] === "bar"`, undefined, handle))).toBe(true);
+  expect(ctx.typeof(json(ctx, undefined))).toBe("undefined");
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("consumeAll", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const o = {};
 
-  const handles = [vm.newObject(), vm.newObject()];
+  const handles = [ctx.newObject(), ctx.newObject()];
   expect(
     consumeAll(
       handles,
-      jest.fn(() => o)
-    )
+      vi.fn(() => o),
+    ),
   ).toBe(o);
-  expect(handles.every((h) => !h.alive)).toBe(true);
+  expect(handles.every(h => !h.alive)).toBe(true);
 
-  const handles2 = [vm.newObject(), vm.newObject()];
+  const handles2 = [ctx.newObject(), ctx.newObject()];
   expect(() =>
     consumeAll(handles2, () => {
       throw new Error("qes error");
-    })
+    }),
   ).toThrow("qes error");
-  expect(handles2.every((h) => !h.alive)).toBe(true);
+  expect(handles2.every(h => !h.alive)).toBe(true);
 
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("mayConsume", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const o = {};
 
-  const handle = vm.newArray();
+  const handle = ctx.newArray();
   expect(
     mayConsume(
       [handle, false],
-      jest.fn<any, [QuickJSHandle]>(() => o)
-    )
+      vi.fn(() => o),
+    ),
   ).toBe(o);
   expect(handle.alive).toBe(true);
 
   mayConsume([handle, true], () => {});
   expect(handle.alive).toBe(false);
 
-  const handle2 = vm.newArray();
+  const handle2 = ctx.newArray();
   expect(() =>
     mayConsume([handle2, true], () => {
       throw new Error("qes error");
-    })
+    }),
   ).toThrow("qes error");
   expect(handle.alive).toBe(false);
 
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("mayConsumeAll", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const o = {};
 
   const handles: [QuickJSHandle, boolean][] = [
-    [vm.newObject(), false],
-    [vm.newObject(), true],
+    [ctx.newObject(), false],
+    [ctx.newObject(), true],
   ];
   expect(
     mayConsumeAll(
       handles,
-      jest.fn<any, QuickJSHandle[]>(() => o)
-    )
+      vi.fn((..._: any[]) => o),
+    ),
   ).toBe(o);
   expect(handles[0][0].alive).toBe(true);
   expect(handles[1][0].alive).toBe(false);
 
   const handles2: [QuickJSHandle, boolean][] = [
-    [vm.newObject(), false],
-    [vm.newObject(), true],
+    [ctx.newObject(), false],
+    [ctx.newObject(), true],
   ];
   expect(() =>
     mayConsumeAll(handles2, (..._args) => {
       throw new Error("qes error");
-    })
+    }),
   ).toThrow("qes error");
   expect(handles2[0][0].alive).toBe(true);
   expect(handles2[1][0].alive).toBe(false);
 
   handles[0][0].dispose();
   handles2[0][0].dispose();
-  vm.dispose();
+  ctx.dispose();
+});
+
+test("handleFrom", async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const handle = ctx.newObject();
+  const promise = ctx.newPromise();
+
+  expect(handleFrom(handle) === handle).toBe(true);
+  expect(handleFrom(promise) === promise.handle).toBe(true);
+
+  handle.dispose();
+  promise.dispose();
+  ctx.dispose();
 });

package/src/vmutil.ts

@@ -1,52 +1,61 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type {
+  Disposable,
+  QuickJSContext,
+  QuickJSHandle,
+  QuickJSDeferredPromise,
+} from "quickjs-emscripten";
+
+export function fn(
+  ctx: QuickJSContext,
+  code: string,
+): ((thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]) => QuickJSHandle) & Disposable {
+  const handle = ctx.unwrapResult(ctx.evalCode(code));
+  const f = (thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]): any => {
+    return ctx.unwrapResult(ctx.callFunction(handle, thisArg ?? ctx.undefined, ...args));
+  };
+  f.dispose = () => handle.dispose();
+  f.alive = true;
+  Object.defineProperty(f, "alive", {
+    get: () => handle.alive,
+  });
+  return f;
+}
 
 export function call(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   code: string,
   thisArg?: QuickJSHandle,
   ...args: QuickJSHandle[]
 ): QuickJSHandle {
-  return vm.unwrapResult(vm.evalCode(code)).consume((f) => {
-    if (typeof thisArg === "undefined" && args.length === 0) return f;
-    return vm.unwrapResult(
-      vm.callFunction(f, thisArg ?? vm.undefined, ...args)
-    );
-  });
+  const f = fn(ctx, code);
+  try {
+    return f(thisArg, ...args);
+  } finally {
+    f.dispose();
+  }
 }
 
-export function eq(vm: QuickJSVm, a: QuickJSHandle, b: QuickJSHandle): boolean {
-  return vm.dump(call(vm, "Object.is", undefined, a, b));
+export function eq(ctx: QuickJSContext, a: QuickJSHandle, b: QuickJSHandle): boolean {
+  return ctx.dump(call(ctx, "Object.is", undefined, a, b));
 }
 
-export function instanceOf(
-  vm: QuickJSVm,
-  a: QuickJSHandle,
-  b: QuickJSHandle
-): boolean {
-  return vm.dump(call(vm, "(a, b) => a instanceof b", undefined, a, b));
+export function instanceOf(ctx: QuickJSContext, a: QuickJSHandle, b: QuickJSHandle): boolean {
+  return ctx.dump(call(ctx, "(a, b) => a instanceof b", undefined, a, b));
 }
 
-export function isHandleObject(vm: QuickJSVm, a: QuickJSHandle): boolean {
-  return vm.dump(
-    call(
-      vm,
-      `a => typeof a === "object" && a !== null || typeof a === "function"`,
-      undefined,
-      a
-    )
+export function isHandleObject(ctx: QuickJSContext, h: QuickJSHandle): boolean {
+  return ctx.dump(
+    call(ctx, `a => typeof a === "object" && a !== null || typeof a === "function"`, undefined, h),
   );
 }
 
-export function json(vm: QuickJSVm, target: any): QuickJSHandle {
+export function json(ctx: QuickJSContext, target: any): QuickJSHandle {
   const json = JSON.stringify(target);
-  if (!json) return vm.undefined;
-  return call(vm, `JSON.parse`, undefined, vm.newString(json));
+  if (!json) return ctx.undefined;
+  return call(ctx, `JSON.parse`, undefined, ctx.newString(json));
 }
 
-export function consumeAll<T extends QuickJSHandle[], K>(
-  handles: T,
-  cb: (handles: T) => K
-): K {
+export function consumeAll<T extends QuickJSHandle[], K>(handles: T, cb: (handles: T) => K): K {
   try {
     return cb(handles);
   } finally {
@@ -58,7 +67,7 @@ export function consumeAll<T extends QuickJSHandle[], K>(
 
 export function mayConsume<T>(
   [handle, shouldBeDisposed]: [QuickJSHandle, boolean],
-  fn: (h: QuickJSHandle) => T
+  fn: (h: QuickJSHandle) => T,
 ) {
   try {
     return fn(handle);
@@ -71,10 +80,10 @@ export function mayConsume<T>(
 
 export function mayConsumeAll<T, H extends QuickJSHandle[]>(
   handles: { [P in keyof H]: [QuickJSHandle, boolean] },
-  fn: (...args: H) => T
+  fn: (...args: H) => T,
 ) {
   try {
-    return fn(...(handles.map((h) => h[0]) as H));
+    return fn(...(handles.map(h => h[0]) as H));
   } finally {
     for (const [handle, shouldBeDisposed] of handles) {
       if (shouldBeDisposed) {
@@ -83,3 +92,11 @@ export function mayConsumeAll<T, H extends QuickJSHandle[]>(
     }
   }
 }
+
+function isQuickJSDeferredPromise(d: Disposable): d is QuickJSDeferredPromise {
+  return "handle" in d;
+}
+
+export function handleFrom(d: QuickJSDeferredPromise | QuickJSHandle): QuickJSHandle {
+  return isQuickJSDeferredPromise(d) ? d.handle : d;
+}