@lvce-editor/renderer-process 7.0.0 → 7.0.1

package/dist/rendererProcessMain.js

@@ -756,7 +756,7 @@ const isSocket = value => {
   return isInstanceOf(value, 'Socket');
 };
 const transferrables = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
+const isTransferrable$1 = value => {
   for (const fn of transferrables) {
     if (fn(value)) {
       return true;
@@ -764,28 +764,28 @@ const isTransferrable = value => {
   }
   return false;
 };
-const walkValue = (value, transferrables) => {
+const walkValue$1 = (value, transferrables) => {
   if (!value) {
     return;
   }
-  if (isTransferrable(value)) {
+  if (isTransferrable$1(value)) {
     transferrables.push(value);
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue(item, transferrables);
+      walkValue$1(item, transferrables);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue(property, transferrables);
+      walkValue$1(property, transferrables);
     }
   }
 };
 const getTransferrables = value => {
   const transferrables = [];
-  walkValue(value, transferrables);
+  walkValue$1(value, transferrables);
   return transferrables;
 };
 const isSingleTransferrable = value => {
@@ -5503,14 +5503,14 @@ class Ipc extends EventTarget {
   }
 }
 const readyMessage = 'ready';
-const listen$3 = () => {
+const listen$4 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$2 = global => {
+const signal$3 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -5535,14 +5535,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$5 = global => {
+const wrap$6 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$3,
-  signal: signal$2,
-  wrap: wrap$5
+  listen: listen$4,
+  signal: signal$3,
+  wrap: wrap$6
 };
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -5760,10 +5760,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$2 = async () => {
-  const parentIpcRaw = listen$3();
-  signal$2(parentIpcRaw);
-  const parentIpc = wrap$5(parentIpcRaw);
+const listen$3 = async () => {
+  const parentIpcRaw = listen$4();
+  signal$3(parentIpcRaw);
+  const parentIpc = wrap$6(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError$1('unexpected first message');
@@ -5802,13 +5802,54 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$4 = port => {
+const wrap$5 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$2,
-  wrap: wrap$4
+  listen: listen$3,
+  wrap: wrap$5
+};
+const isTransferrable = value => {
+  return value instanceof MessagePort;
+};
+const walkValue = (value, transferrables) => {
+  if (!value) {
+    return value;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      const newItem = walkValue(item, transferrables);
+      newItems.push(newItem);
+    }
+    return newItems;
+  }
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      const newValue = walkValue(property, transferrables);
+      newObject[key] = newValue;
+    }
+    return newObject;
+  }
+  return value;
+};
+
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = [];
+  const newValue = walkValue(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
 };
 const listen$1 = () => {
   return window;
@@ -5823,8 +5864,12 @@ class IpcChildWithWindow extends Ipc {
   send(message) {
     this._rawIpc.postMessage(message);
   }
-  sendAndTransfer(message, transfer) {
-    this._rawIpc.postMessage(message, location.origin, transfer);
+  sendAndTransfer(message, _transfer) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
   }
   dispose() {
     // ignore
@@ -5849,13 +5894,13 @@ class IpcChildWithWindow extends Ipc {
 const wrap$3 = window => {
   return new IpcChildWithWindow(window);
 };
-const IpcChildWithWindow$1 = {
+const IpcChildWithElectronWindow = {
   __proto__: null,
   listen: listen$1,
   signal: signal$1,
   wrap: wrap$3
 };
-const listen$4 = ({
+const listen$2 = ({
   port
 }) => {
   return port;
@@ -5892,7 +5937,7 @@ const wrap$2 = port => {
 };
 const IpcChildWithMessagePort$1 = {
   __proto__: null,
-  listen: listen$4,
+  listen: listen$2,
   signal,
   wrap: wrap$2
 };
@@ -6195,7 +6240,7 @@ const create$x = async ({
   if (!isElectron) {
     throw new Error('Electron api was requested but is not available');
   }
-  const windowIpc = IpcChildWithWindow$1.wrap(window);
+  const windowIpc = IpcChildWithElectronWindow.wrap(window);
   handleIpcOnce(windowIpc);
   const webContentsIds = await invokeAndTransfer$1(windowIpc, 'CreateMessagePort.createMessagePort', ipcId, port);
   return webContentsIds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "",
   "main": "dist/diffWorkerMain.js",
   "type": "module",