quickjs-emscripten-sync 1.4.0 → 1.5.0

package/src/unmarshal/object.ts

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

package/src/unmarshal/primitive.test.ts

@@ -10,10 +10,7 @@ test("works", async () => {
   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.newString("hoge"))).toEqual(["hoge", true]);
   expect(unmarshalPrimitive(ctx, ctx.newNumber(-10))).toEqual([-10, true]);
   // expect(
   //   unmarshalPrimitive(ctx, ctx.unwrapResult(vm.evalCode(`BigInt(1)`)))

package/src/unmarshal/primitive.ts

@@ -2,22 +2,15 @@ import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 export default function unmarshalPrimitive(
   ctx: QuickJSContext,
-  handle: QuickJSHandle
+  handle: QuickJSHandle,
 ): [any, boolean] {
   const ty = ctx.typeof(handle);
-  if (
-    ty === "undefined" ||
-    ty === "number" ||
-    ty === "string" ||
-    ty === "boolean"
-  ) {
+  if (ty === "undefined" || ty === "number" || ty === "string" || ty === "boolean") {
     return [ctx.dump(handle), true];
   } else if (ty === "object") {
     const isNull = ctx
       .unwrapResult(ctx.evalCode("a => a === null"))
-      .consume((n) =>
-        ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))
-      );
+      .consume(n => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle))));
     if (isNull) {
       return [null, true];
     }

package/src/unmarshal/promise.test.ts

@@ -7,13 +7,13 @@ 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) => {
+    const f = ctx.newFunction(v.name, h => {
       v(ctx.dump(h));
     });
     disposables.push(f);
     return [f, false];
   });
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
   const deferred = ctx.newPromise();
   disposables.push(deferred);
@@ -36,7 +36,7 @@ const testPromise = (reject: boolean) => async () => {
     expect(promise).resolves.toBe("hoge");
   }
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   ctx.dispose();
 };
 

package/src/unmarshal/promise.ts

@@ -8,21 +8,14 @@ export default function unmarshalPromise<T = unknown>(
   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
+  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
-  );
+  call(ctx, "(p, res, rej) => { p.then(res, rej); }", undefined, handle, resHandle, rejHandle);
   if (resShouldBeDisposed) resHandle.dispose();
   if (rejShouldBeDisposed) rejHandle.dispose();
 
@@ -31,7 +24,7 @@ export default function unmarshalPromise<T = unknown>(
 
 function isPromiseHandle(ctx: QuickJSContext, handle: QuickJSHandle): boolean {
   if (!handle.owner) return false;
-  return ctx.unwrapResult(ctx.evalCode("Promise")).consume((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

@@ -21,7 +21,7 @@ test("works", async () => {
         c: { get: () => {}, set: () => {} },
       });
       obj
-    }`)
+    }`),
   );
 
   unmarshalProperties(ctx, handle, obj, unmarshal);
@@ -47,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();
   ctx.dispose();
 });

package/src/unmarshal/properties.ts

@@ -6,16 +6,12 @@ export default function unmarshalProperties(
   ctx: QuickJSContext,
   handle: QuickJSHandle,
   target: object | Function,
-  unmarshal: (handle: QuickJSHandle) => [unknown, boolean]
+  unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
 ) {
   ctx
     .newFunction("", (key, value) => {
       const [keyName] = unmarshal(key);
-      if (
-        typeof keyName !== "string" &&
-        typeof keyName !== "number" &&
-        typeof keyName !== "symbol"
-      )
+      if (typeof keyName !== "string" && typeof keyName !== "number" && typeof keyName !== "symbol")
         return;
 
       const desc = (
@@ -48,7 +44,7 @@ export default function unmarshalProperties(
 
       Object.defineProperty(target, keyName, desc);
     })
-    .consume((fn) => {
+    .consume(fn => {
       call(
         ctx,
         `(o, fn) => {
@@ -58,7 +54,7 @@ export default function unmarshalProperties(
       }`,
         undefined,
         handle,
-        fn
+        fn,
       ).dispose();
     });
 }

package/src/util.test.ts

@@ -1,12 +1,6 @@
 import { expect, test, vi } from "vitest";
 
-import {
-  isES2015Class,
-  isObject,
-  walkObject,
-  complexity,
-  newDeferred,
-} from "./util";
+import { isES2015Class, isObject, walkObject, complexity, newDeferred } from "./util";
 
 test("isES2015Class", () => {
   expect(isES2015Class(class {})).toBe(true);

package/src/util.ts

@@ -1,19 +1,14 @@
 export function isES2015Class(cls: any): cls is new (...args: any[]) => any {
-  return (
-    typeof cls === "function" &&
-    /^class\s/.test(Function.prototype.toString.call(cls))
-  );
+  return typeof cls === "function" && /^class\s/.test(Function.prototype.toString.call(cls));
 }
 
 export function isObject(value: any): value is object | Function {
-  return (
-    typeof value === "function" || (typeof value === "object" && value !== null)
-  );
+  return typeof value === "function" || (typeof value === "object" && value !== null);
 }
 
 export function walkObject(
   value: any,
-  callback?: (target: any, set: Set<any>) => boolean | void
+  callback?: (target: any, set: Set<any>) => boolean | void,
 ): Set<any> {
   const set = new Set<any>();
   const walk = (v: any) => {

package/src/vmmap.ts

@@ -42,9 +42,9 @@ export default class VMMap {
             map2 = new WeakMap();
           }
         };
-      }`)
+      }`),
       )
-      .consume((fn) => this._call(fn, undefined));
+      .consume(fn => this._call(fn, undefined));
 
     this._mapGet = ctx.getProp(result, "get");
     this._mapSet = ctx.getProp(result, "set");
@@ -59,12 +59,7 @@ export default class VMMap {
     this._disposables.add(this._mapClear);
   }
 
-  set(
-    key: any,
-    handle: QuickJSHandle,
-    key2?: any,
-    handle2?: QuickJSHandle
-  ): boolean {
+  set(key: any, handle: QuickJSHandle, key2?: any, handle2?: QuickJSHandle): boolean {
     if (!handle.alive || (handle2 && !handle2.alive)) return false;
 
     const v = this.get(key) ?? this.get(key2);
@@ -84,14 +79,8 @@ export default class VMMap {
       }
     }
 
-    this.ctx.newNumber(counter).consume((c) => {
-      this._call(
-        this._mapSet,
-        undefined,
-        handle,
-        c,
-        handle2 ?? this.ctx.undefined
-      );
+    this.ctx.newNumber(counter).consume(c => {
+      this._call(this._mapSet, undefined, handle, c, handle2 ?? this.ctx.undefined);
     });
 
     return true;
@@ -103,7 +92,7 @@ export default class VMMap {
           | [any, QuickJSHandle | undefined]
           | [any, QuickJSHandle | undefined, any, QuickJSHandle | undefined]
         >
-      | undefined
+      | undefined,
   ) {
     if (!iteratable) return;
     for (const iter of iteratable) {
@@ -131,9 +120,7 @@ export default class VMMap {
     if (!handle.alive) {
       return;
     }
-    return this._counterMap.get(
-      this.ctx.getNumber(this._call(this._mapGet, undefined, handle))
-    );
+    return this._counterMap.get(this.ctx.getNumber(this._call(this._mapGet, undefined, handle)));
   }
 
   has(key: any) {
@@ -157,7 +144,7 @@ export default class VMMap {
     this._call(
       this._mapDelete,
       undefined,
-      ...[handle, handle2].filter((h): h is QuickJSHandle => !!h?.alive)
+      ...[handle, handle2].filter((h): h is QuickJSHandle => !!h?.alive),
     );
 
     this._map1.delete(key);
@@ -235,12 +222,11 @@ export default class VMMap {
     return this._map1.size;
   }
 
-  [Symbol.iterator](): Iterator<
-    [any, QuickJSHandle, any, QuickJSHandle | undefined]
-  > {
+  [Symbol.iterator](): Iterator<[any, QuickJSHandle, any, QuickJSHandle | undefined]> {
     const keys = this._map1.keys();
     return {
       next: () => {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
           const k1 = keys.next();
           if (k1.done) return { value: undefined, done: true };
@@ -262,17 +248,13 @@ export default class VMMap {
     }
   }
 
-  _call(
-    fn: QuickJSHandle,
-    thisArg: QuickJSHandle | undefined,
-    ...args: QuickJSHandle[]
-  ) {
+  _call(fn: QuickJSHandle, thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]) {
     return this.ctx.unwrapResult(
       this.ctx.callFunction(
         fn,
         typeof thisArg === "undefined" ? this.ctx.undefined : thisArg,
-        ...args
-      )
+        ...args,
+      ),
     );
   }
 }

package/src/vmutil.test.ts

@@ -18,9 +18,7 @@ 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
-  );
+  expect(ctx.getNumber(f(undefined, ctx.newNumber(1), ctx.newNumber(2)))).toBe(3);
 
   const obj = ctx.newObject();
   ctx.setProp(obj, "a", ctx.newNumber(2));
@@ -41,22 +39,12 @@ test("call", async () => {
   const ctx = (await getQuickJS()).newContext();
 
   expect(
-    ctx.getNumber(
-      call(
-        ctx,
-        "(a, b) => a + b",
-        undefined,
-        ctx.newNumber(1),
-        ctx.newNumber(2)
-      )
-    )
+    ctx.getNumber(call(ctx, "(a, b) => a + b", undefined, ctx.newNumber(1), ctx.newNumber(2))),
   ).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);
+  expect(ctx.getNumber(call(ctx, "(function() { return this.a + 1; })", obj))).toBe(3);
 
   obj.dispose();
   ctx.dispose();
@@ -117,9 +105,7 @@ test("json", async () => {
   const handle = json(ctx, {
     hoge: { foo: ["bar"] },
   });
-  expect(
-    ctx.dump(call(ctx, `a => a.hoge.foo[0] === "bar"`, undefined, handle))
-  ).toBe(true);
+  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();
@@ -135,18 +121,18 @@ test("consumeAll", async () => {
   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 = [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();
 });
@@ -160,8 +146,8 @@ test("mayConsume", async () => {
   expect(
     mayConsume(
       [handle, false],
-      vi.fn(() => o)
-    )
+      vi.fn(() => o),
+    ),
   ).toBe(o);
   expect(handle.alive).toBe(true);
 
@@ -172,7 +158,7 @@ test("mayConsume", async () => {
   expect(() =>
     mayConsume([handle2, true], () => {
       throw new Error("qes error");
-    })
+    }),
   ).toThrow("qes error");
   expect(handle.alive).toBe(false);
 
@@ -191,8 +177,8 @@ test("mayConsumeAll", async () => {
   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);
@@ -204,7 +190,7 @@ test("mayConsumeAll", async () => {
   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);

package/src/vmutil.ts

@@ -7,20 +7,11 @@ import type {
 
 export function fn(
   ctx: QuickJSContext,
-  code: string
-): ((
-  thisArg: QuickJSHandle | undefined,
-  ...args: QuickJSHandle[]
-) => QuickJSHandle) &
-  Disposable {
+  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)
-    );
+  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;
@@ -44,30 +35,17 @@ export function call(
   }
 }
 
-export function eq(
-  ctx: QuickJSContext,
-  a: QuickJSHandle,
-  b: QuickJSHandle
-): boolean {
+export function eq(ctx: QuickJSContext, a: QuickJSHandle, b: QuickJSHandle): boolean {
   return ctx.dump(call(ctx, "Object.is", undefined, a, b));
 }
 
-export function instanceOf(
-  ctx: QuickJSContext,
-  a: QuickJSHandle,
-  b: QuickJSHandle
-): boolean {
+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(ctx: QuickJSContext, h: QuickJSHandle): boolean {
   return ctx.dump(
-    call(
-      ctx,
-      `a => typeof a === "object" && a !== null || typeof a === "function"`,
-      undefined,
-      h
-    )
+    call(ctx, `a => typeof a === "object" && a !== null || typeof a === "function"`, undefined, h),
   );
 }
 
@@ -77,10 +55,7 @@ export function json(ctx: QuickJSContext, target: any): QuickJSHandle {
   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 {
@@ -92,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);
@@ -105,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) {
@@ -122,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;
 }