quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/wrapper.ts

@@ -1,4 +1,5 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
+
 import { isObject } from "./util";
 import { call, isHandleObject, consumeAll, mayConsumeAll } from "./vmutil";
 
@@ -7,14 +8,23 @@ 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, boolean],
-  syncMode?: (target: T) => SyncMode | undefined
+  syncMode?: (target: T) => SyncMode | undefined,
+  wrappable?: (target: unknown) => boolean,
 ): Wrapped<T> | undefined {
-  if (!isObject(target)) return undefined;
+  // promise and date cannot be wrapped
+  if (
+    !isObject(target) ||
+    target instanceof Promise ||
+    target instanceof Date ||
+    (wrappable && !wrappable(target))
+  )
+    return undefined;
+
   if (isWrapped(target, proxyKeySymbol)) return target;
 
   const rec = new Proxy(target as any, {
@@ -24,80 +34,66 @@ 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)) ||
-        sync === "host" ||
-        !vm.alive
-      )
+      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(
-            vm,
-            receiverHandle,
-            proxyKeySymbolHandle
-          );
+          const [handle2, unwrapped] = unwrapHandle(ctx, receiverHandle, proxyKeySymbolHandle);
           if (unwrapped) {
-            handle2.consume((h) => vm.setProp(h, keyHandle, valueHandle));
+            handle2.consume(h => ctx.setProp(h, keyHandle, valueHandle));
           } else {
-            vm.setProp(handle2, keyHandle, valueHandle);
+            ctx.setProp(handle2, keyHandle, valueHandle);
           }
-        }
+        },
       );
 
       return true;
     },
     deleteProperty(obj, key) {
       const sync = syncMode?.(rec) ?? "host";
-      return mayConsumeAll(
-        [marshal(rec), marshal(key)],
-        (recHandle, keyHandle) => {
-          const [handle2, unwrapped] = unwrapHandle(
-            vm,
-            recHandle,
-            proxyKeySymbolHandle
-          );
-
-          if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-            if (sync === "host" || !vm.alive) return true;
-
-            if (unwrapped) {
-              handle2.consume((h) =>
-                call(vm, `(a, b) => delete a[b]`, undefined, h, keyHandle)
-              );
-            } else {
-              call(vm, `(a, b) => delete a[b]`, undefined, handle2, keyHandle);
-            }
+      return mayConsumeAll([marshal(rec), marshal(key)], (recHandle, keyHandle) => {
+        const [handle2, unwrapped] = unwrapHandle(ctx, recHandle, proxyKeySymbolHandle);
+
+        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
+  syncMode?: (target: QuickJSHandle) => SyncMode | undefined,
+  wrappable?: (target: QuickJSHandle, ctx: QuickJSContext) => boolean,
 ): [Wrapped<QuickJSHandle> | undefined, boolean] {
-  if (!isHandleObject(vm, handle)) return [undefined, false];
-  if (isHandleWrapped(vm, handle, proxyKeySymbolHandle)) return [handle, false];
+  if (!isHandleObject(ctx, handle) || (wrappable && !wrappable(handle, ctx)))
+    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);
@@ -105,16 +101,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) {
@@ -147,10 +143,10 @@ export function wrapHandle(
         undefined,
         handle,
         proxyKeySymbolHandle,
-        ...args
+        ...args,
       ) as Wrapped<QuickJSHandle>,
       true,
-    ]
+    ],
   );
 }
 
@@ -159,12 +155,12 @@ export function unwrap<T>(obj: T, key: string | symbol): T {
 }
 
 export function unwrapHandle(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
-  key: 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> {
@@ -172,17 +168,18 @@ export function isWrapped<T>(obj: T, key: string | symbol): obj is Wrapped<T> {
 }
 
 export function isHandleWrapped(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
-  key: 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 and date cannot be wrapped
+      `(a, s) => (a instanceof Promise) || (a instanceof Date) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`,
       undefined,
       handle,
-      key
-    )
+      key,
+    ),
   );
 }