quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/wrapper.ts

@@ -1,20 +1,22 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
+
 import { isObject } from "./util";
-import { call, isHandleObject, consumeAll } from "./vmutil";
+import { call, isHandleObject, consumeAll, mayConsumeAll } from "./vmutil";
 
 export type SyncMode = "both" | "vm" | "host";
 
 export type Wrapped<T> = T & { __qes_wrapped: never };
 
 export function wrap<T = any>(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: T,
   proxyKeySymbol: symbol,
   proxyKeySymbolHandle: QuickJSHandle,
-  marshal: (target: any) => QuickJSHandle,
+  marshal: (target: any) => [QuickJSHandle, boolean],
   syncMode?: (target: T) => SyncMode | undefined
 ): Wrapped<T> | undefined {
-  if (!isObject(target)) return undefined;
+  // promise cannot be wrapped
+  if (!isObject(target) || target instanceof Promise) return undefined;
   if (isWrapped(target, proxyKeySymbol)) return target;
 
   const rec = new Proxy(target as any, {
@@ -24,63 +26,81 @@ export function wrap<T = any>(
     set(obj, key, value, receiver) {
       const v = unwrap(value, proxyKeySymbol);
       const sync = syncMode?.(receiver) ?? "host";
-      if (sync === "vm" || Reflect.set(obj, key, v, receiver)) {
-        if (sync === "host") return true;
-        const [handle2, unwrapped] = unwrapHandle(
-          vm,
-          marshal(receiver),
-          proxyKeySymbolHandle
-        );
-        if (unwrapped) {
-          handle2.consume(h => vm.setProp(h, marshal(key), marshal(v)));
-        } else {
-          vm.setProp(handle2, marshal(key), marshal(v));
+      if (
+        (sync !== "vm" && !Reflect.set(obj, key, v, receiver)) ||
+        sync === "host" ||
+        !ctx.alive
+      )
+        return true;
+
+      mayConsumeAll(
+        [marshal(receiver), marshal(key), marshal(v)],
+        (receiverHandle, keyHandle, valueHandle) => {
+          const [handle2, unwrapped] = unwrapHandle(
+            ctx,
+            receiverHandle,
+            proxyKeySymbolHandle
+          );
+          if (unwrapped) {
+            handle2.consume((h) => ctx.setProp(h, keyHandle, valueHandle));
+          } else {
+            ctx.setProp(handle2, keyHandle, valueHandle);
+          }
         }
-      }
+      );
+
       return true;
     },
     deleteProperty(obj, key) {
       const sync = syncMode?.(rec) ?? "host";
-      const [handle2, unwrapped] = unwrapHandle(
-        vm,
-        marshal(rec),
-        proxyKeySymbolHandle
-      );
-      if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-        if (sync === "host") return true;
-        if (unwrapped) {
-          handle2.consume(h =>
-            call(vm, `(a, b) => delete a[b]`, undefined, h, marshal(key))
+      return mayConsumeAll(
+        [marshal(rec), marshal(key)],
+        (recHandle, keyHandle) => {
+          const [handle2, unwrapped] = unwrapHandle(
+            ctx,
+            recHandle,
+            proxyKeySymbolHandle
           );
-        } else {
-          call(vm, `(a, b) => delete a[b]`, undefined, handle2, marshal(key));
+
+          if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
+            if (sync === "host" || !ctx.alive) return true;
+
+            if (unwrapped) {
+              handle2.consume((h) =>
+                call(ctx, `(a, b) => delete a[b]`, undefined, h, keyHandle)
+              );
+            } else {
+              call(ctx, `(a, b) => delete a[b]`, undefined, handle2, keyHandle);
+            }
+          }
+          return true;
         }
-      }
-      return true;
+      );
     },
   }) as Wrapped<T>;
   return rec;
 }
 
 export function wrapHandle(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   proxyKeySymbol: symbol,
   proxyKeySymbolHandle: QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => any,
   syncMode?: (target: QuickJSHandle) => SyncMode | undefined
 ): [Wrapped<QuickJSHandle> | undefined, boolean] {
-  if (!isHandleObject(vm, handle)) return [undefined, false];
-  if (isHandleWrapped(vm, handle, proxyKeySymbolHandle)) return [handle, false];
+  if (!isHandleObject(ctx, handle)) return [undefined, false];
+  if (isHandleWrapped(ctx, handle, proxyKeySymbolHandle))
+    return [handle, false];
 
   return consumeAll(
     [
-      vm.newFunction("getSyncMode", h => {
+      ctx.newFunction("getSyncMode", (h) => {
         const res = syncMode?.(unmarshal(h));
-        if (typeof res === "string") return vm.newString(res);
-        return vm.undefined;
+        if (typeof res === "string") return ctx.newString(res);
+        return ctx.undefined;
       }),
-      vm.newFunction("setter", (h, keyHandle, valueHandle) => {
+      ctx.newFunction("setter", (h, keyHandle, valueHandle) => {
         const target = unmarshal(h);
         if (!target) return;
         const key = unmarshal(keyHandle);
@@ -88,16 +108,16 @@ export function wrapHandle(
         const value = unmarshal(valueHandle);
         unwrap(target, proxyKeySymbol)[key] = value;
       }),
-      vm.newFunction("deleter", (h, keyHandle) => {
+      ctx.newFunction("deleter", (h, keyHandle) => {
         const target = unmarshal(h);
         if (!target) return;
         const key = unmarshal(keyHandle);
         delete unwrap(target, proxyKeySymbol)[key];
       }),
     ],
-    args => [
+    (args) => [
       call(
-        vm,
+        ctx,
         `(target, sym, getSyncMode, setter, deleter) => {
           const rec =  new Proxy(target, {
             get(obj, key, receiver) {
@@ -142,12 +162,12 @@ export function unwrap<T>(obj: T, key: string | symbol): T {
 }
 
 export function unwrapHandle(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   key: QuickJSHandle
 ): [QuickJSHandle, boolean] {
-  if (!isHandleWrapped(vm, handle, key)) return [handle, false];
-  return [vm.getProp(handle, key), true];
+  if (!isHandleWrapped(ctx, handle, key)) return [handle, false];
+  return [ctx.getProp(handle, key), true];
 }
 
 export function isWrapped<T>(obj: T, key: string | symbol): obj is Wrapped<T> {
@@ -155,14 +175,15 @@ export function isWrapped<T>(obj: T, key: string | symbol): obj is Wrapped<T> {
 }
 
 export function isHandleWrapped(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   key: QuickJSHandle
 ): handle is Wrapped<QuickJSHandle> {
-  return !!vm.dump(
+  return !!ctx.dump(
     call(
-      vm,
-      `(a, s) => (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`,
+      ctx,
+      // promise cannot be wrapped
+      `(a, s) => (a instanceof Promise) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`,
       undefined,
       handle,
       key

package/dist/default.d.ts

@@ -1,4 +0,0 @@
-/**
- * Default value of registeredObjects option of the Arena class constructor.
- */
-export declare const defaultRegisteredObjects: [any, string][];

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./quickjs-emscripten-sync.cjs.production.min.js')
-} else {
-  module.exports = require('./quickjs-emscripten-sync.cjs.development.js')
-}

package/dist/marshal/function.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalFunction(vm: QuickJSVm, target: unknown, marshal: (target: unknown) => QuickJSHandle, unmarshal: (handle: QuickJSHandle) => unknown, preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined, preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any): QuickJSHandle | undefined;

package/dist/marshal/index.d.ts

@@ -1,11 +0,0 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
-export declare type Options = {
-    vm: QuickJSVm;
-    unmarshal: (handle: QuickJSHandle) => unknown;
-    isMarshalable?: (target: unknown) => boolean;
-    find: (target: unknown) => QuickJSHandle | undefined;
-    pre: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined;
-    preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
-};
-export declare function marshal(target: unknown, options: Options): QuickJSHandle;
-export default marshal;

package/dist/marshal/object.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalObject(vm: QuickJSVm, target: unknown, marshal: (target: unknown) => QuickJSHandle, preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined): QuickJSHandle | undefined;

package/dist/marshal/primitive.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalPrimitive(vm: QuickJSVm, target: unknown): QuickJSHandle | undefined;

package/dist/marshal/properties.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalProperties(vm: QuickJSVm, target: object | Function, handle: QuickJSHandle, marshal: (target: unknown) => QuickJSHandle): void;

package/dist/marshal/symbol.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalSymbol(vm: QuickJSVm, target: unknown, preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined): QuickJSHandle | undefined;