quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/unmarshal/object.test.ts

@@ -1,16 +1,18 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+  const ctx = (await getQuickJS()).newContext();
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1, b: true })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1, b: true })`));
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({ a: 1, b: true });
   expect(unmarshal).toReturnTimes(4);
@@ -22,20 +24,20 @@ test("normal object", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("properties", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  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 preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  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 },
@@ -45,7 +47,7 @@ test("properties", async () => {
       obj
     }`)
   );
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({
     a: 1,
@@ -70,21 +72,21 @@ test("properties", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
+  const ctx = (await getQuickJS()).newContext();
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`[1, true, "a"]`));
-  const array = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`[1, true, "a"]`));
+  const array = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   expect((array as any)[0]).toEqual(1);
   expect(Array.isArray(array)).toBe(true);
   expect(unmarshal.mock.results[0].value).toEqual(["0", false]);
@@ -98,19 +100,21 @@ test("array", async () => {
   expect(preUnmarshal).toBeCalledWith(array, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("prototype", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.typeof(v) === "object" ? { a: () => 1 } : vm.dump(v),
+  const ctx = (await getQuickJS()).newContext();
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
+    ctx.typeof(v) === "object" ? { a: () => 1 } : ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`Object.create({ a: () => 1 })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal) as any;
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`Object.create({ a: () => 1 })`)
+  );
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal) as any;
   if (!obj) throw new Error("obj is undefined");
   expect(Object.getPrototypeOf(obj)).toEqual({ a: expect.any(Function) });
   expect(obj.a()).toBe(1);
@@ -120,25 +124,25 @@ test("prototype", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
+  const ctx = (await getQuickJS()).newContext();
+  const f = vi.fn();
 
-  expect(unmarshalObject(vm, vm.undefined, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.true, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.false, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.null, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newString("hoge"), f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newNumber(-10), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.undefined, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.true, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.false, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.null, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newString("hoge"), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newNumber(-10), f, f)).toEqual(undefined);
 
-  const func = vm.newFunction("", () => {});
-  expect(unmarshalObject(vm, func, f, f)).toEqual(undefined);
+  const func = ctx.newFunction("", () => {});
+  expect(unmarshalObject(ctx, func, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/object.ts

@@ -1,41 +1,42 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import unmarshalProperties from "./properties";
 import { call } from "../vmutil";
 
 export default function unmarshalObject(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
   preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
 ): object | undefined {
   if (
-    vm.typeof(handle) !== "object" ||
+    ctx.typeof(handle) !== "object" ||
     // null check
-    vm
-      .unwrapResult(vm.evalCode("o => o === null"))
-      .consume(n =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
+    ctx
+      .unwrapResult(ctx.evalCode("o => o === null"))
+      .consume((n) =>
+        ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))
       )
   )
     return;
 
-  const raw = call(vm, "Array.isArray", undefined, handle).consume(r =>
-    vm.dump(r)
+  const raw = call(ctx, "Array.isArray", undefined, handle).consume((r) =>
+    ctx.dump(r)
   )
     ? []
     : {};
   const obj = preUnmarshal(raw, handle) ?? raw;
 
   const prototype = call(
-    vm,
+    ctx,
     `o => {
       const p = Object.getPrototypeOf(o);
       return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
     }`,
     undefined,
     handle
-  ).consume(prototype => {
-    if (vm.typeof(prototype) === "undefined") return;
+  ).consume((prototype) => {
+    if (ctx.typeof(prototype) === "undefined") return;
     const [proto] = unmarshal(prototype);
     return proto;
   });
@@ -43,7 +44,7 @@ export default function unmarshalObject(
     Object.setPrototypeOf(obj, prototype);
   }
 
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return obj;
 }

package/src/unmarshal/primitive.test.ts

@@ -1,28 +1,33 @@
 import { getQuickJS } from "quickjs-emscripten";
+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"))
-      .consume(n =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
+    const isNull = ctx
+      .unwrapResult(ctx.evalCode("a => a === null"))
+      .consume((n) =>
+        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

@@ -0,0 +1,44 @@
+import { Disposable, getQuickJS, type QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import unmarshalPromise from "./promise";
+
+const testPromise = (reject: boolean) => async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => {
+    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 = ctx.newPromise();
+  disposables.push(deferred);
+  const promise = unmarshalPromise(ctx, deferred.handle, marshal, preUnmarshal);
+
+  expect(marshal).toBeCalledTimes(2);
+  expect(preUnmarshal).toBeCalledTimes(1);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject(ctx.newString("hoge"));
+  } else {
+    deferred.resolve(ctx.newString("hoge"));
+  }
+  expect(ctx.runtime.hasPendingJob()).toBe(true);
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
+  if (reject) {
+    expect(promise).rejects.toThrow("hoge");
+  } else {
+    expect(promise).resolves.toBe("hoge");
+  }
+
+  disposables.forEach((d) => d.dispose());
+  ctx.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/unmarshal/promise.ts

@@ -0,0 +1,38 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { newDeferred } from "../util";
+import { call, instanceOf } from "../vmutil";
+
+export default function unmarshalPromise<T = unknown>(
+  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(ctx, handle)) return;
+
+  const deferred = newDeferred<T>();
+  const [resHandle, resShouldBeDisposed] = marshal(deferred.resolve);
+  const [rejHandle, rejShouldBeDisposed] = marshal(deferred.reject);
+  call(
+    ctx,
+    "(p, res, rej) => { p.then(res, rej); }",
+    undefined,
+    handle,
+    resHandle,
+    rejHandle
+  );
+  if (resShouldBeDisposed) resHandle.dispose();
+  if (rejShouldBeDisposed) rejHandle.dispose();
+
+  return preUnmarshal(deferred.promise, handle) ?? deferred.promise;
+}
+
+function isPromiseHandle(ctx: QuickJSContext, handle: QuickJSHandle): boolean {
+  if (!handle.owner) return false;
+  return ctx.unwrapResult(ctx.evalCode("Promise")).consume((promise) => {
+    if (!handle.owner) return false;
+    return instanceOf(ctx, handle, promise);
+  });
+}

package/src/unmarshal/properties.test.ts

@@ -1,17 +1,19 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+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 = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  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 },
@@ -22,7 +24,7 @@ test("works", async () => {
     }`)
   );
 
-  unmarshalProperties(vm, handle, obj, unmarshal);
+  unmarshalProperties(ctx, handle, obj, unmarshal);
 
   expect(obj).toEqual({
     a: 1,
@@ -45,7 +47,7 @@ test("works", async () => {
   expect(unmarshal).toReturnWith(["c", false]);
   expect(unmarshal).toReturnWith([expect.any(Function), false]); // get, set
 
-  disposables.forEach(d => d.dispose());
+  disposables.forEach((d) => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/properties.ts

@@ -1,59 +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

@@ -1,16 +1,18 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalSymbol from "./symbol";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const pre = jest.fn();
-  const obj = vm.newObject();
-  const handle = vm.unwrapResult(vm.evalCode(`Symbol("foobar")`));
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
+  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);
@@ -19,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,9 +1,17 @@
-import { isES2015Class, isObject, walkObject, complexity } from "./util";
+import { expect, test, vi } from "vitest";
+
+import {
+  isES2015Class,
+  isObject,
+  walkObject,
+  complexity,
+  newDeferred,
+} from "./util";
 
 test("isES2015Class", () => {
   expect(isES2015Class(class {})).toBe(true);
   expect(isES2015Class(class A {})).toBe(true);
-  expect(isES2015Class(function() {})).toBe(false);
+  expect(isES2015Class(function () {})).toBe(false);
   expect(isES2015Class(function A() {})).toBe(false);
   expect(isES2015Class(() => {})).toBe(false);
   expect(isES2015Class({})).toBe(false);
@@ -14,7 +22,7 @@ test("isES2015Class", () => {
 test("isObject", () => {
   expect(isObject({})).toBe(true);
   expect(isObject(Object.create(null))).toBe(true);
-  expect(isObject(function() {})).toBe(true);
+  expect(isObject(function () {})).toBe(true);
   expect(isObject(function A() {})).toBe(true);
   expect(isObject(() => {})).toBe(true);
   expect(isObject(class {})).toBe(true);
@@ -25,7 +33,7 @@ test("isObject", () => {
 });
 
 test("walkObject", () => {
-  const cb = jest.fn();
+  const cb = vi.fn();
   const obj = { a: { b: 1, c: () => {} } };
   const set = new Set<any>([obj, obj.a, obj.a.c]);
   expect(walkObject(obj, cb)).toEqual(set);
@@ -47,8 +55,18 @@ test("complexity", () => {
   expect(complexity({ a: 1 })).toBe(1);
   expect(complexity(() => {})).toBe(1);
   expect(complexity([{}])).toBe(2);
-  expect(complexity(function() {})).toBe(2);
+  expect(complexity(function () {})).toBe(2);
   expect(complexity(class {})).toBe(2);
   expect(complexity({ a: {} })).toBe(2);
   expect(complexity({ a: {} }, 1)).toBe(1);
 });
+
+test("newDeferred", () => {
+  const deferred = newDeferred();
+  deferred.resolve("foo");
+  expect(deferred.promise).resolves.toBe("foo");
+
+  const deferred2 = newDeferred();
+  deferred2.reject("bar");
+  expect(deferred2.promise).rejects.toBe("bar");
+});