@lvce-editor/renderer-process 13.15.0 → 13.16.0

package/dist/rendererProcessMain.js

@@ -297,9 +297,9 @@ const initializeModule = module => {
     for (const [key, value] of Object.entries(module.Commands)) {
       if (module.name) {
         const actualKey = `${module.name}.${key}`;
-        register(actualKey, value);
+        register$1(actualKey, value);
       } else {
-        register(key, value);
+        register$1(key, value);
       }
     }
     return;
@@ -327,7 +327,7 @@ const getOrLoadModule = moduleId => {
 const loadCommand = async command => {
   await getOrLoadModule(getModuleId(command));
 };
-const register = (commandId, listener) => {
+const register$1 = (commandId, listener) => {
   state$a.commands[commandId] = listener;
 };
 const hasThrown = new Set();
@@ -344,9 +344,9 @@ const executeCommandAsync = async (command, ...args) => {
     hasThrown.add(command);
     throw new Error(`Command did not register "${command}"`);
   }
-  return execute(command, ...args);
+  return execute$1(command, ...args);
 };
-const execute = (command, ...args) => {
+const execute$1 = (command, ...args) => {
   if (command in state$a.commands) {
     const fn = state$a.commands[command];
     if (typeof fn !== 'function') {
@@ -839,30 +839,30 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
-const requiresSocket = () => {
+const requiresSocket$1 = () => {
   return false;
 };
-const preparePrettyError = error => {
+const preparePrettyError$1 = error => {
   return error;
 };
-const logError$1 = error => {
+const logError$2 = error => {
   // error is logged in renderer worker
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError$1, requiresSocket);
+const handleMessage$1 = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute$1, resolve, preparePrettyError$1, logError$2, requiresSocket$1);
 };
 
-const handleIpc = ipc => {
+const handleIpc$1 = ipc => {
   if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
+    ipc.addEventListener('message', handleMessage$1);
   } else {
     // deprevated
-    ipc.onmessage = handleMessage;
+    ipc.onmessage = handleMessage$1;
   }
 };
 const unhandleIpc = ipc => {
   if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage);
+    ipc.removeEventListener('message', handleMessage$1);
   } else {
     // deprecated
     ipc.onmessage = null;
@@ -992,7 +992,7 @@ const state$9 = {
 };
 const hydrate$4 = async () => {
   const ipc = await launchRendererWorker();
-  handleIpc(ipc);
+  handleIpc$1(ipc);
   // @ts-expect-error
   state$9.ipc = ipc;
 };
@@ -3489,14 +3489,14 @@ const getMessage = error => {
   return `Error: ${error}`;
 };
 
-const logError = async (error, prefix = '') => {
+const logError$1 = async (error, prefix = '') => {
   const prettyError = await prepare(error);
   print(prettyError, prefix);
   return prettyError;
 };
 const handleError$6 = async (error, notify = true, prefix = '') => {
   try {
-    const prettyError = await logError(error, prefix);
+    const prettyError = await logError$1(error, prefix);
     if (notify) {
       alert(getMessage(prettyError));
     }
@@ -3780,7 +3780,7 @@ const create$z = async ({
     throw new IpcError$1(`worker must be of type Worker`);
   }
   const ipc = wrap(worker);
-  handleIpc(ipc);
+  handleIpc$1(ipc);
   // TODO await promise
   // TODO call separate method HandleMessagePort.handleMessagePort or
   // HandleIncomingIpc.handleIncomingIpc
@@ -3794,17 +3794,6 @@ const IpcParentWithModuleWorkerWithMessagePort = {
   create: create$z
 };
 
-const handleIpcOnce = ipc => {
-  if (ipc.addEventListener) {
-    ipc.addEventListener('message', handleMessage, {
-      once: true
-    });
-  } else {
-    // deprecated
-    ipc.onmessage = handleMessage;
-  }
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -4306,6 +4295,81 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   wrap: wrap$e
 };
 
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
+
+const createRpc = ipc => {
+  const rpc = {
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send$1(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke$2(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer$1(ipc, method, ...params);
+    },
+    async dispose() {
+      await ipc?.dispose();
+    }
+  };
+  return rpc;
+};
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const create$f$1 = async ({
+  commandMap,
+  window
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = IpcChildWithElectronWindow$1.wrap(window);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const ElectronWindowRpcClient = {
+  __proto__: null,
+  create: create$f$1
+};
+
 // TODO use handleIncomingIpc function
 const create$y = async ({
   port,
@@ -4315,9 +4379,11 @@ const create$y = async ({
   if (!isElectron) {
     throw new Error('Electron api was requested but is not available');
   }
-  const windowIpc = IpcChildWithElectronWindow$1.wrap(window);
-  handleIpcOnce(windowIpc);
-  const webContentsIds = await invokeAndTransfer$1(windowIpc, 'CreateMessagePort.createMessagePort', ipcId, port);
+  const rpc = await ElectronWindowRpcClient.create({
+    commandMap: {},
+    window
+  });
+  const webContentsIds = await rpc.invokeAndTransfer('CreateMessagePort.createMessagePort', ipcId, port);
   return webContentsIds;
 };
 
@@ -11113,7 +11179,7 @@ const handleMessagePort = async port => {
     method: MessagePort$1,
     port
   });
-  handleIpc(ipc);
+  handleIpc$1(ipc);
 };
 
 const name$1 = 'HandleMessagePort';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "13.15.0",
+  "version": "13.16.0",
   "description": "",
   "keywords": [
     "lvce-editor",