quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/vmutil.test.ts

@@ -1,123 +1,229 @@
-import { getQuickJS } from "quickjs-emscripten";
+import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import {
+  fn,
   call,
   consumeAll,
   eq,
   instanceOf,
   isHandleObject,
-  send,
+  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));
+  const obj = ctx.newObject();
+  ctx.setProp(obj, "a", ctx.newNumber(2));
   expect(
-    vm.getNumber(call(vm, "(function() { return this.a + 1; })", obj))
+    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("send", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+test("json", async () => {
+  const ctx = (await getQuickJS()).newContext();
 
-  const handle = send(vm, {
+  const handle = json(ctx, {
     hoge: { foo: ["bar"] },
   });
   expect(
-    vm.dump(call(vm, `a => a.hoge.foo[0] === "bar"`, undefined, handle))
+    ctx.dump(call(ctx, `a => a.hoge.foo[0] === "bar"`, undefined, handle))
   ).toBe(true);
-  expect(vm.typeof(send(vm, undefined))).toBe("undefined");
+  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);
+
+  ctx.dispose();
+});
+
+test("mayConsume", async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const o = {};
+
+  const handle = ctx.newArray();
+  expect(
+    mayConsume(
+      [handle, false],
+      vi.fn(() => o)
+    )
+  ).toBe(o);
+  expect(handle.alive).toBe(true);
+
+  mayConsume([handle, true], () => {});
+  expect(handle.alive).toBe(false);
+
+  const handle2 = ctx.newArray();
+  expect(() =>
+    mayConsume([handle2, true], () => {
+      throw new Error("qes error");
+    })
+  ).toThrow("qes error");
+  expect(handle.alive).toBe(false);
+
+  ctx.dispose();
+});
+
+test("mayConsumeAll", async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const o = {};
+
+  const handles: [QuickJSHandle, boolean][] = [
+    [ctx.newObject(), false],
+    [ctx.newObject(), true],
+  ];
+  expect(
+    mayConsumeAll(
+      handles,
+      vi.fn((..._: any[]) => o)
+    )
+  ).toBe(o);
+  expect(handles[0][0].alive).toBe(true);
+  expect(handles[1][0].alive).toBe(false);
+
+  const handles2: [QuickJSHandle, boolean][] = [
+    [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);
 
-  vm.dispose();
+  handles[0][0].dispose();
+  handles2[0][0].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,46 +1,80 @@
-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,
+  ctx: QuickJSContext,
   a: QuickJSHandle,
   b: QuickJSHandle
 ): boolean {
-  return vm.dump(call(vm, "(a, b) => a instanceof b", undefined, a, b));
+  return ctx.dump(call(ctx, "(a, b) => a instanceof b", undefined, a, b));
 }
 
-export function isHandleObject(vm: QuickJSVm, a: QuickJSHandle): boolean {
-  return vm.dump(
+export function isHandleObject(ctx: QuickJSContext, h: QuickJSHandle): boolean {
+  return ctx.dump(
     call(
-      vm,
+      ctx,
       `a => typeof a === "object" && a !== null || typeof a === "function"`,
       undefined,
-      a
+      h
     )
   );
 }
 
-export function send(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>(
@@ -55,3 +89,41 @@ export function consumeAll<T extends QuickJSHandle[], K>(
     }
   }
 }
+
+export function mayConsume<T>(
+  [handle, shouldBeDisposed]: [QuickJSHandle, boolean],
+  fn: (h: QuickJSHandle) => T
+) {
+  try {
+    return fn(handle);
+  } finally {
+    if (shouldBeDisposed) {
+      handle.dispose();
+    }
+  }
+}
+
+export function mayConsumeAll<T, H extends QuickJSHandle[]>(
+  handles: { [P in keyof H]: [QuickJSHandle, boolean] },
+  fn: (...args: H) => T
+) {
+  try {
+    return fn(...(handles.map((h) => h[0]) as H));
+  } finally {
+    for (const [handle, shouldBeDisposed] of handles) {
+      if (shouldBeDisposed) {
+        handle.dispose();
+      }
+    }
+  }
+}
+
+function isQuickJSDeferredPromise(d: Disposable): d is QuickJSDeferredPromise {
+  return "handle" in d;
+}
+
+export function handleFrom(
+  d: QuickJSDeferredPromise | QuickJSHandle
+): QuickJSHandle {
+  return isQuickJSDeferredPromise(d) ? d.handle : d;
+}