quickjs-emscripten-sync 1.3.0 → 1.4.0

package/src/unmarshal/primitive.test.ts

@@ -4,27 +4,30 @@ import { expect, test } from "vitest";
 import unmarshalPrimitive from "./primitive";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  expect(unmarshalPrimitive(vm, vm.undefined)).toEqual([undefined, true]);
-  expect(unmarshalPrimitive(vm, vm.true)).toEqual([true, true]);
-  expect(unmarshalPrimitive(vm, vm.false)).toEqual([false, true]);
-  expect(unmarshalPrimitive(vm, vm.null)).toEqual([null, true]);
-  expect(unmarshalPrimitive(vm, vm.newString("hoge"))).toEqual(["hoge", true]);
-  expect(unmarshalPrimitive(vm, vm.newNumber(-10))).toEqual([-10, true]);
+  expect(unmarshalPrimitive(ctx, ctx.undefined)).toEqual([undefined, true]);
+  expect(unmarshalPrimitive(ctx, ctx.true)).toEqual([true, true]);
+  expect(unmarshalPrimitive(ctx, ctx.false)).toEqual([false, true]);
+  expect(unmarshalPrimitive(ctx, ctx.null)).toEqual([null, true]);
+  expect(unmarshalPrimitive(ctx, ctx.newString("hoge"))).toEqual([
+    "hoge",
+    true,
+  ]);
+  expect(unmarshalPrimitive(ctx, ctx.newNumber(-10))).toEqual([-10, true]);
   // expect(
-  //   unmarshalPrimitive(vm, vm.unwrapResult(vm.evalCode(`BigInt(1)`)))
+  //   unmarshalPrimitive(ctx, ctx.unwrapResult(vm.evalCode(`BigInt(1)`)))
   // ).toEqual([BigInt(1), true]);
 
-  const obj = vm.newObject();
-  expect(unmarshalPrimitive(vm, obj)).toEqual([undefined, false]);
-  const array = vm.newArray();
-  expect(unmarshalPrimitive(vm, array)).toEqual([undefined, false]);
-  const func = vm.newFunction("", () => {});
-  expect(unmarshalPrimitive(vm, func)).toEqual([undefined, false]);
+  const obj = ctx.newObject();
+  expect(unmarshalPrimitive(ctx, obj)).toEqual([undefined, false]);
+  const array = ctx.newArray();
+  expect(unmarshalPrimitive(ctx, array)).toEqual([undefined, false]);
+  const func = ctx.newFunction("", () => {});
+  expect(unmarshalPrimitive(ctx, func)).toEqual([undefined, false]);
 
   obj.dispose();
   array.dispose();
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/primitive.ts

@@ -1,22 +1,22 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 export default function unmarshalPrimitive(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle
 ): [any, boolean] {
-  const ty = vm.typeof(handle);
+  const ty = ctx.typeof(handle);
   if (
     ty === "undefined" ||
     ty === "number" ||
     ty === "string" ||
     ty === "boolean"
   ) {
-    return [vm.dump(handle), true];
+    return [ctx.dump(handle), true];
   } else if (ty === "object") {
-    const isNull = vm
-      .unwrapResult(vm.evalCode("a => a === null"))
+    const isNull = ctx
+      .unwrapResult(ctx.evalCode("a => a === null"))
       .consume((n) =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
+        ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))
       );
     if (isNull) {
       return [null, true];
@@ -25,10 +25,10 @@ export default function unmarshalPrimitive(
 
   // BigInt is not supported by quickjs-emscripten
   // if (ty === "bigint") {
-  //   const str = vm
+  //   const str = ctx
   //     .getProp(handle, "toString")
   //     .consume(toString => vm.unwrapResult(vm.callFunction(toString, handle)))
-  //     .consume(str => vm.getString(str));
+  //     .consume(str => ctx.getString(str));
   //   const bi = BigInt(str);
   //   return [bi, true];
   // }

package/src/unmarshal/promise.test.ts

@@ -4,32 +4,32 @@ import { expect, test, vi } from "vitest";
 import unmarshalPromise from "./promise";
 
 const testPromise = (reject: boolean) => async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: Disposable[] = [];
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => {
-    const f = vm.newFunction(v.name, (h) => {
-      v(vm.dump(h));
+    const f = ctx.newFunction(v.name, (h) => {
+      v(ctx.dump(h));
     });
     disposables.push(f);
     return [f, false];
   });
   const preUnmarshal = vi.fn((a) => a);
 
-  const deferred = vm.newPromise();
+  const deferred = ctx.newPromise();
   disposables.push(deferred);
-  const promise = unmarshalPromise(vm, deferred.handle, marshal, preUnmarshal);
+  const promise = unmarshalPromise(ctx, deferred.handle, marshal, preUnmarshal);
 
   expect(marshal).toBeCalledTimes(2);
   expect(preUnmarshal).toBeCalledTimes(1);
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
 
   if (reject) {
-    deferred.reject(vm.newString("hoge"));
+    deferred.reject(ctx.newString("hoge"));
   } else {
-    deferred.resolve(vm.newString("hoge"));
+    deferred.resolve(ctx.newString("hoge"));
   }
-  expect(vm.hasPendingJob()).toBe(true);
-  expect(vm.unwrapResult(vm.executePendingJobs())).toBe(1);
+  expect(ctx.runtime.hasPendingJob()).toBe(true);
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
   if (reject) {
     expect(promise).rejects.toThrow("hoge");
   } else {
@@ -37,7 +37,7 @@ const testPromise = (reject: boolean) => async () => {
   }
 
   disposables.forEach((d) => d.dispose());
-  vm.dispose();
+  ctx.dispose();
 };
 
 test("resolve", testPromise(false));

package/src/unmarshal/promise.ts

@@ -1,22 +1,22 @@
-import type { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { newDeferred } from "../util";
 import { call, instanceOf } from "../vmutil";
 
 export default function unmarshalPromise<T = unknown>(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   /** marshal returns handle and boolean indicates that the handle should be disposed after use */
   marshal: (value: unknown) => [QuickJSHandle, boolean],
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): Promise<T> | undefined {
-  if (!isPromiseHandle(handle)) return;
+  if (!isPromiseHandle(ctx, handle)) return;
 
   const deferred = newDeferred<T>();
   const [resHandle, resShouldBeDisposed] = marshal(deferred.resolve);
   const [rejHandle, rejShouldBeDisposed] = marshal(deferred.reject);
   call(
-    vm,
+    ctx,
     "(p, res, rej) => { p.then(res, rej); }",
     undefined,
     handle,
@@ -29,12 +29,10 @@ export default function unmarshalPromise<T = unknown>(
   return preUnmarshal(deferred.promise, handle) ?? deferred.promise;
 }
 
-function isPromiseHandle(handle: QuickJSHandle): boolean {
+function isPromiseHandle(ctx: QuickJSContext, handle: QuickJSHandle): boolean {
   if (!handle.owner) return false;
-  return handle.owner
-    .unwrapResult(handle.owner.evalCode("Promise"))
-    .consume((promise) => {
-      if (!handle.owner) return false;
-      return instanceOf(handle.owner, handle, promise);
-    });
+  return ctx.unwrapResult(ctx.evalCode("Promise")).consume((promise) => {
+    if (!handle.owner) return false;
+    return instanceOf(ctx, handle, promise);
+  });
 }

package/src/unmarshal/properties.test.ts

@@ -4,16 +4,16 @@ import { expect, test, vi } from "vitest";
 import unmarshalProperties from "./properties";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
-    return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
+    return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
   const obj = {};
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       const obj = {};
       Object.defineProperties(obj, {
         a: { value: 1, writable: true, configurable: true, enumerable: true },
@@ -24,7 +24,7 @@ test("works", async () => {
     }`)
   );
 
-  unmarshalProperties(vm, handle, obj, unmarshal);
+  unmarshalProperties(ctx, handle, obj, unmarshal);
 
   expect(obj).toEqual({
     a: 1,
@@ -49,5 +49,5 @@ test("works", async () => {
 
   disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/properties.ts

@@ -1,61 +1,64 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
 export default function unmarshalProperties(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   target: object | Function,
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean]
 ) {
-  vm.newFunction("", (key, value) => {
-    const [keyName] = unmarshal(key);
-    if (
-      typeof keyName !== "string" &&
-      typeof keyName !== "number" &&
-      typeof keyName !== "symbol"
-    )
-      return;
+  ctx
+    .newFunction("", (key, value) => {
+      const [keyName] = unmarshal(key);
+      if (
+        typeof keyName !== "string" &&
+        typeof keyName !== "number" &&
+        typeof keyName !== "symbol"
+      )
+        return;
 
-    const desc = (
-      [
-        ["value", true],
-        ["get", true],
-        ["set", true],
-        ["configurable", false],
-        ["enumerable", false],
-        ["writable", false],
-      ] as const
-    ).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
-      const h = vm.getProp(value, key);
-      const ty = vm.typeof(h);
+      const desc = (
+        [
+          ["value", true],
+          ["get", true],
+          ["set", true],
+          ["configurable", false],
+          ["enumerable", false],
+          ["writable", false],
+        ] as const
+      ).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
+        const h = ctx.getProp(value, key);
+        const ty = ctx.typeof(h);
 
-      if (ty === "undefined") return desc;
-      if (!unmarshable && ty === "boolean") {
-        desc[key] = vm.dump(vm.getProp(value, key));
-        return desc;
-      }
+        if (ty === "undefined") return desc;
+        if (!unmarshable && ty === "boolean") {
+          desc[key] = ctx.dump(ctx.getProp(value, key));
+          return desc;
+        }
 
-      const [v, alreadyExists] = unmarshal(h);
-      if (alreadyExists) {
-        h.dispose();
-      }
-      desc[key] = v;
+        const [v, alreadyExists] = unmarshal(h);
+        if (alreadyExists) {
+          h.dispose();
+        }
+        desc[key] = v;
 
-      return desc;
-    }, {});
+        return desc;
+      }, {});
 
-    Object.defineProperty(target, keyName, desc);
-  }).consume((fn) => {
-    call(
-      vm,
-      `(o, fn) => {
+      Object.defineProperty(target, keyName, desc);
+    })
+    .consume((fn) => {
+      call(
+        ctx,
+        `(o, fn) => {
         const descs = Object.getOwnPropertyDescriptors(o);
         Object.entries(descs).forEach(([k, v]) => fn(k, v));
         Object.getOwnPropertySymbols(descs).forEach(k => fn(k, descs[k]));
       }`,
-      undefined,
-      handle,
-      fn
-    ).dispose();
-  });
+        undefined,
+        handle,
+        fn
+      ).dispose();
+    });
 }

package/src/unmarshal/symbol.test.ts

@@ -4,15 +4,15 @@ import { expect, test, vi } from "vitest";
 import unmarshalSymbol from "./symbol";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const pre = vi.fn();
-  const obj = vm.newObject();
-  const handle = vm.unwrapResult(vm.evalCode(`Symbol("foobar")`));
+  const obj = ctx.newObject();
+  const handle = ctx.unwrapResult(ctx.evalCode(`Symbol("foobar")`));
 
-  expect(unmarshalSymbol(vm, obj, pre)).toBe(undefined);
+  expect(unmarshalSymbol(ctx, obj, pre)).toBe(undefined);
   expect(pre).toBeCalledTimes(0);
 
-  const sym = unmarshalSymbol(vm, handle, pre);
+  const sym = unmarshalSymbol(ctx, handle, pre);
   expect(typeof sym).toBe("symbol");
   expect((sym as any).description).toBe("foobar");
   expect(pre).toReturnTimes(1);
@@ -21,5 +21,5 @@ test("works", async () => {
 
   handle.dispose();
   obj.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/symbol.ts

@@ -1,12 +1,12 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 export default function unmarshalSymbol(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): symbol | undefined {
-  if (vm.typeof(handle) !== "symbol") return;
-  const desc = vm.getString(vm.getProp(handle, "description"));
+  if (ctx.typeof(handle) !== "symbol") return;
+  const desc = ctx.getString(ctx.getProp(handle, "description"));
   const sym = Symbol(desc);
   return preUnmarshal(sym, handle) ?? sym;
 }

package/src/util.test.ts

@@ -1,4 +1,5 @@
 import { expect, test, vi } from "vitest";
+
 import {
   isES2015Class,
   isObject,