quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/vmutil.test.ts

@@ -15,16 +15,15 @@ import {
 } from "./vmutil";
 
 test("fn", async () => {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const f = fn(vm, "(a, b) => a + b");
-  expect(vm.getNumber(f(undefined, vm.newNumber(1), vm.newNumber(2)))).toBe(3);
+  const f = fn(ctx, "(a, b) => a + b");
+  expect(ctx.getNumber(f(undefined, ctx.newNumber(1), ctx.newNumber(2)))).toBe(3);
 
-  const obj = vm.newObject();
-  vm.setProp(obj, "a", vm.newNumber(2));
-  const f2 = fn(vm, "(function() { return this.a + 1; })");
-  expect(vm.getNumber(f2(obj))).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);
@@ -33,199 +32,184 @@ test("fn", async () => {
   f.dispose();
   expect(f.alive).toBe(false);
   expect(f2.alive).toBe(false);
-  vm.dispose();
+  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,
-      vi.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],
-      vi.fn(() => 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,
-      vi.fn((..._: any[]) => 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 quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  const handle = vm.newObject();
-  const promise = vm.newPromise();
+  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();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/vmutil.ts

@@ -1,26 +1,17 @@
 import type {
   Disposable,
-  QuickJSVm,
+  QuickJSContext,
   QuickJSHandle,
   QuickJSDeferredPromise,
 } from "quickjs-emscripten";
 
 export function fn(
-  vm: QuickJSVm,
-  code: string
-): ((
-  thisArg: QuickJSHandle | undefined,
-  ...args: QuickJSHandle[]
-) => QuickJSHandle) &
-  Disposable {
-  const handle = vm.unwrapResult(vm.evalCode(code));
-  const f = (
-    thisArg: QuickJSHandle | undefined,
-    ...args: QuickJSHandle[]
-  ): any => {
-    return vm.unwrapResult(
-      vm.callFunction(handle, thisArg ?? vm.undefined, ...args)
-    );
+  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;
@@ -31,12 +22,12 @@ export function fn(
 }
 
 export function call(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   code: string,
   thisArg?: QuickJSHandle,
   ...args: QuickJSHandle[]
 ): QuickJSHandle {
-  const f = fn(vm, code);
+  const f = fn(ctx, code);
   try {
     return f(thisArg, ...args);
   } finally {
@@ -44,39 +35,27 @@ export function call(
   }
 }
 
-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 {
@@ -88,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);
@@ -101,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) {
@@ -118,8 +97,6 @@ function isQuickJSDeferredPromise(d: Disposable): d is QuickJSDeferredPromise {
   return "handle" in d;
 }
 
-export function handleFrom(
-  d: QuickJSDeferredPromise | QuickJSHandle
-): QuickJSHandle {
+export function handleFrom(d: QuickJSDeferredPromise | QuickJSHandle): QuickJSHandle {
   return isQuickJSDeferredPromise(d) ? d.handle : d;
 }