@lvce-editor/main-process 2.4.0 → 2.5.0

package/dist/mainProcessMain.js

@@ -5,6 +5,7 @@ import { inspect } from 'node:util';
 import { spawn } from 'node:child_process';
 import { MessageChannel } from 'node:worker_threads';
 import { createWriteStream, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import * as NodePath from 'node:path';
 import { dirname } from 'node:path';
 import require$$1 from 'tty';
@@ -12,7 +13,6 @@ import require$$1$1 from 'util';
 import require$$0 from 'os';
 import { Console } from 'node:console';
 import { tmpdir, homedir } from 'node:os';
-import { fileURLToPath } from 'node:url';
 
 function escapeStringRegexp(string) {
   if (typeof string !== 'string') {
@@ -757,7 +757,7 @@ const getNewLineIndex$2 = (string, startIndex = undefined) => {
 
 // TODO disable logging via environment variable, don't enable logging during tests
 
-const state$8 = {
+const state$7 = {
   console: undefined
 };
 const createConsole = () => {
@@ -767,8 +767,8 @@ const createConsole = () => {
   return logger;
 };
 const getOrCreateLogger = () => {
-  state$8.console ||= createConsole();
-  return state$8.console;
+  state$7.console ||= createConsole();
+  return state$7.console;
 };
 const info = (...args) => {
   const logger = getOrCreateLogger();
@@ -2707,7 +2707,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$1 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$4 = id => {
@@ -2726,7 +2726,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$1(id, resolve);
   return {
     id,
     promise
@@ -3337,7 +3337,7 @@ const launchSharedProcess = async ({
   return sharedProcessRpc;
 };
 
-const state$7 = {
+const state$6 = {
   /**
    * @type {any}
    */
@@ -3348,14 +3348,14 @@ const getOrCreate = async ({
   method,
   env = {}
 }) => {
-  if (!state$7.promise) {
+  if (!state$6.promise) {
     // @ts-ignore
-    state$7.promise = launchSharedProcess({
+    state$6.promise = launchSharedProcess({
       method,
       env
     });
   }
-  return state$7.promise;
+  return state$6.promise;
 };
 const send$1 = async (method, ...params) => {
   const rpc = await getOrCreate({
@@ -4478,14 +4478,14 @@ const createTitleBar = items => {
 
 const PHASE_DEFAULT = 0;
 const PHASE_SHUTDOWN = -1;
-const state$6 = {
+const state$5 = {
   phase: PHASE_DEFAULT
 };
 const isShutDown = () => {
-  return state$6.phase === PHASE_SHUTDOWN;
+  return state$5.phase === PHASE_SHUTDOWN;
 };
 const setShutDown = () => {
-  state$6.phase = PHASE_SHUTDOWN;
+  state$5.phase = PHASE_SHUTDOWN;
 };
 
 // TODO move this function to shared process
@@ -4782,21 +4782,21 @@ const BeforeInputEvent = 'before-input-event';
 const Allow = 'allow';
 const Deny = 'deny';
 
-const state$5 = {
+const state$4 = {
   views: Object.create(null),
   fallThroughKeyBindings: [],
   canceled: Object.create(null)
 };
 const add$1 = (id, browserWindow, view) => {
   // state
-  state$5.views[id] = {
+  state$4.views[id] = {
     browserWindow,
     view
   };
 };
 const hasWebContents = id => {
   number(id);
-  return id in state$5.views;
+  return id in state$4.views;
 };
 /**
  *
@@ -4804,19 +4804,19 @@ const hasWebContents = id => {
  * @returns {{browserWindow: Electron.BrowserWindow, view: Electron.WebContentsView}}
  */
 const get$3 = id => {
-  return state$5.views[id];
+  return state$4.views[id];
 };
 const remove$1 = id => {
-  delete state$5.views[id];
+  delete state$4.views[id];
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  state$5.fallThroughKeyBindings = fallthroughKeyBindings;
+  state$4.fallThroughKeyBindings = fallthroughKeyBindings;
 };
 const getFallthroughKeyBindings = () => {
-  return state$5.fallThroughKeyBindings;
+  return state$4.fallThroughKeyBindings;
 };
 const setCanceled = id => {
-  state$5.canceled[id] = true;
+  state$4.canceled[id] = true;
 };
 
 const shouldAllowNavigation = webContentsId => {
@@ -4829,6 +4829,7 @@ const shouldAllowNavigation = webContentsId => {
 const handleWebContentsWindowOpen = ({
   url
 }) => {
+  // @ts-ignore
   void undefined(url);
   return {
     action: Deny
@@ -4891,13 +4892,6 @@ const privilegedSchems = [{
   }
 }];
 
-/**
- *
- * @param {Electron.Protocol} protocol
- * @param {string} name
- * @param {(request: GlobalRequest) => Promise<GlobalResponse>} handleRequest
- * @returns
- */
 const handle = (protocol, name, handleRequest) => {
   if (isProtocolHandleApiSupported(protocol)) {
     protocol.handle(name, handleRequest);
@@ -4905,12 +4899,6 @@ const handle = (protocol, name, handleRequest) => {
   }
   throw new Error('protocol.handle api is not supported');
 };
-
-/**
- *
- * @param {Electron.Protocol} protocol
- * @returns
- */
 const enable = protocol => {
   protocol.registerSchemesAsPrivileged(privilegedSchems);
 };
@@ -5123,7 +5111,7 @@ const getModuleId = commandId => {
   }
 };
 
-const state$4 = {
+const state$3 = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {}
@@ -5143,21 +5131,21 @@ const initializeModule = module => {
   throw new Error(`module ${module.name || '<unnamed module>'} is missing commands`);
 };
 const getOrLoadModule = moduleId => {
-  if (!state$4.pendingModules[moduleId]) {
-    const importPromise = state$4.load(moduleId);
-    state$4.pendingModules[moduleId] = importPromise.then(initializeModule);
+  if (!state$3.pendingModules[moduleId]) {
+    const importPromise = state$3.load(moduleId);
+    state$3.pendingModules[moduleId] = importPromise.then(initializeModule);
   }
-  return state$4.pendingModules[moduleId];
+  return state$3.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId(command));
 const register = (commandId, listener) => {
-  state$4.commands[commandId] = listener;
+  state$3.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const loadThenExecute = async (command, ...args) => {
   await loadCommand(command);
   // TODO can skip then block in prod (only to prevent endless loop in dev)
-  if (!(command in state$4.commands)) {
+  if (!(command in state$3.commands)) {
     if (hasThrown.has(command)) {
       return;
     }
@@ -5167,13 +5155,13 @@ const loadThenExecute = async (command, ...args) => {
   return execute(command, ...args);
 };
 const execute = (command, ...args) => {
-  if (command in state$4.commands) {
-    return state$4.commands[command](...args);
+  if (command in state$3.commands) {
+    return state$3.commands[command](...args);
   }
   return loadThenExecute(command, ...args);
 };
 const setLoad = load => {
-  state$4.load = load;
+  state$3.load = load;
 };
 
 const ClipBoardRead = 'clipboard-read';
@@ -5265,110 +5253,32 @@ const createElectronSession = () => {
   return session;
 };
 
-const state$3 = {
+const state$2 = {
   session: undefined
 };
 const has = () => {
-  return Boolean(state$3.session);
+  return Boolean(state$2.session);
 };
 const get$2 = () => {
-  if (!state$3.session) {
+  if (!state$2.session) {
     throw new Error('session is not defined');
   }
-  return state$3.session;
-};
-const set$1 = value => {
-  state$3.session = value;
-};
-
-const printPrettyError = (prettyError, prefix = '') => {
-  error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
+  return state$2.session;
 };
-
-const logError = (error, prettyError) => {
-  printPrettyError(prettyError, '[main-process] ');
-};
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, prepare,
-  // @ts-ignore
-  logError, requiresSocket);
+const set = value => {
+  state$2.session = value;
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
-};
-const unhandleIpc = ipc => {
-  if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage);
-  } else if ('off' in ipc) {
-    ipc.off('message', handleMessage);
-  }
-};
-
-const NodeWorker = 1;
-const NodeForkedProcess = 2;
-const ElectronUtilityProcess = 3;
-const ElectronMessagePort = 4;
-
-const getModule$2 = method => {
-  switch (method) {
-    case NodeWorker:
-      return IpcParentWithNodeWorker$1;
-    case NodeForkedProcess:
-      return IpcParentWithNodeForkedProcess$1;
-    case ElectronUtilityProcess:
-      return Promise.resolve().then(function () { return IpcParentWithElectronUtilityProcess; });
-    case ElectronMessagePort:
-      return IpcParentWithElectronMessagePort$1;
-    default:
-      throw new Error(`unexpected ipc type ${method}`);
-  }
-};
-
-/**
- *
- * @param {*} param0
- * @returns {Promise<any>}
- */
-const create$2 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$2(method);
-  // @ts-ignore
-  const rawIpc = await module.create(options);
-  // @ts-ignore
-  if (module.effects) {
-    // @ts-ignore
-    module.effects({
-      rawIpc,
-      ...options
-    });
-  }
-  if (options.noReturn) {
-    return undefined;
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const create$1 = ipc => {
+const create$2 = rpc => {
   const handleRequest = async request => {
     const {
       method,
       url
     } = request;
-    console.log('got request', method, url);
     const {
       body,
       init
-    } = await invoke$1(ipc, 'WebViewProtocol.getResponse', method, url);
+    } = await rpc.invoke('WebViewProtocol.getResponse', method, url);
     return new Response(body, init);
   };
   return handleRequest;
@@ -5376,23 +5286,19 @@ const create$1 = ipc => {
 
 const get$1 = () => {
   if (!has()) {
-    set$1(createElectronSession());
+    set(createElectronSession());
   }
   return get$2();
 };
 const registerWebviewProtocol = async port => {
   object(port);
-  console.log('will register ptorocol');
-  const ipc = await create$2({
-    method: ElectronMessagePort,
-    messagePort: port
+  const rpc = await ElectronMessagePortRpcClient.create({
+    commandMap: {},
+    messagePort: port,
+    requiresSocket: requiresSocket
   });
-  console.log('do register protocol');
-  handleIpc(ipc);
-  port.start();
   const session = get$1();
-  const handleRequest = create$1(ipc);
-  // @ts-ignore
+  const handleRequest = create$2(rpc);
   handle(session.protocol, WebView, handleRequest);
 };
 
@@ -5511,7 +5417,12 @@ const connectIpc$1 = async (rpc, browserWindowPort, ...params) => {
   browserWindowPort.start();
 };
 
-const getModule$1 = method => {
+const NodeWorker = 1;
+const NodeForkedProcess = 2;
+const ElectronUtilityProcess = 3;
+const ElectronMessagePort = 4;
+
+const getModule$2 = method => {
   switch (method) {
     case NodeWorker:
       return connectIpc$1;
@@ -5522,7 +5433,7 @@ const getModule$1 = method => {
   }
 };
 const connectIpc = async (method, rpc, browserWindowPort, ipcId) => {
-  const connectIpc = getModule$1(method);
+  const connectIpc = getModule$2(method);
   return connectIpc(rpc, browserWindowPort, ipcId);
 };
 
@@ -5558,27 +5469,27 @@ const createMessagePort = async (ipcId, port, webContentsId) => {
   return webContentsId;
 };
 
-const state$2 = {
+const state$1 = {
   all: Object.create(null)
 };
 const add = (pid, process, name) => {
   number(pid);
   object(process);
   string(name);
-  state$2.all[pid] = {
+  state$1.all[pid] = {
     process,
     name
   };
 };
 const remove = pid => {
   number(pid);
-  delete state$2.all[pid];
+  delete state$1.all[pid];
 };
 const getAll = () => {
-  return Object.entries(state$2.all);
+  return Object.entries(state$1.all);
 };
 const getByName = name => {
-  for (const value of Object.values(state$2.all)) {
+  for (const value of Object.values(state$1.all)) {
     // @ts-ignore
     if (value.name === name) {
       // @ts-ignore
@@ -5645,7 +5556,8 @@ const createUtilityProcessRpc = async options => {
     commandMap: commandMapRef,
     ...options
   });
-  set$3(options.rpcId, rpc);
+  const rpcId = options.targetRpcId || options.rpcId || options.ipcId;
+  set$3(rpcId, rpc);
 };
 
 const serializeDeskopCapturerSource = source => {
@@ -6596,7 +6508,7 @@ const filter = {
   urls: ['<all_urls>']
 };
 
-const state$1 = {
+const state = {
   session: undefined
 };
 const isAllowedPermission = permission => {
@@ -6629,24 +6541,16 @@ const createSession = () => {
   return session;
 };
 const getSession = () => {
-  state$1.session ||= createSession();
-  return state$1.session;
+  state.session ||= createSession();
+  return state.session;
 };
 
-const state = {
-  ipc: undefined
-};
-const set = ipc => {
-  state.ipc = ipc;
-};
 const send = (method, ...params) => {
-  const {
-    ipc
-  } = state;
-  if (!ipc) {
+  const rpc = get(EmbedsProcess);
+  if (!rpc) {
     return;
   }
-  send$2(ipc, method, ...params);
+  return rpc.send(method, ...params);
 };
 
 // TODO use electron 30 webcontentsview api
@@ -6945,7 +6849,36 @@ const getStats$1 = view => {
   };
 };
 
-const getModule = method => {
+const printPrettyError = (prettyError, prefix = '') => {
+  error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
+};
+
+const logError = (error, prettyError) => {
+  printPrettyError(prettyError, '[main-process] ');
+};
+const handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, prepare,
+  // @ts-ignore
+  logError, requiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage);
+  } else if ('off' in ipc) {
+    ipc.off('message', handleMessage);
+  }
+};
+
+const getModule$1 = method => {
   switch (method) {
     case NodeForkedProcess$1:
       return IpcChildWithNodeForkedProcess$1;
@@ -6966,7 +6899,7 @@ const listen = async ({
   method,
   ...params
 }) => {
-  const module = getModule(method);
+  const module = getModule$1(method);
   // @ts-ignore
   const rawIpc = await module.listen(params);
   // @ts-ignore
@@ -7033,18 +6966,62 @@ const getWindowId = webContentsId => {
   return browserWindow.id;
 };
 
-const handleElectronMessagePort = async (messagePort, ipcId) => {
+const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const ipc = await listen({
-    method: ElectronMessagePort$1,
-    messagePort
+  const rpc = await ElectronMessagePortRpcClient.create({
+    messagePort: messagePort,
+    commandMap: commandMapRef,
+    requiresSocket: requiresSocket
   });
-  handleIpc(ipc);
-  if (ipcId === EmbedsProcess) {
-    set(ipc);
+  if (rpcId) {
+    set$3(rpcId, rpc);
   }
 };
 
+const getModule = method => {
+  switch (method) {
+    case NodeWorker:
+      return IpcParentWithNodeWorker$1;
+    case NodeForkedProcess:
+      return IpcParentWithNodeForkedProcess$1;
+    case ElectronUtilityProcess:
+      return Promise.resolve().then(function () { return IpcParentWithElectronUtilityProcess; });
+    case ElectronMessagePort:
+      return IpcParentWithElectronMessagePort$1;
+    default:
+      throw new Error(`unexpected ipc type ${method}`);
+  }
+};
+
+/**
+ *
+ * @param {*} param0
+ * @returns {Promise<any>}
+ * @deprecated
+ */
+const create$1 = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.create(options);
+  // @ts-ignore
+  if (module.effects) {
+    // @ts-ignore
+    module.effects({
+      rawIpc,
+      ...options
+    });
+  }
+  if (options.noReturn) {
+    return undefined;
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
 const shouldOpenExternal = url => {
   if (url.startsWith('http:') || url.startsWith('https:')) {
     return true;
@@ -7130,6 +7107,10 @@ const createPortTuple = async (id1, id2) => {
   } = getPortTuple();
   await invokeAndTransfer('TemporaryMessagePort.handlePorts', port1, port2, id1, id2);
 };
+
+/**
+ * @deprecated
+ */
 const sendTo = async (port, name, ipcId) => {
   string(name);
   object(port);
@@ -7142,10 +7123,13 @@ const sendTo = async (port, name, ipcId) => {
 };
 
 // TODO use rpc id, and then use rpc.invokeAndtransfer
-const sendTo2 = async (port, rpcId) => {
+const sendTo2 = async (port, targetRpcId, sourceRpcId) => {
   object(port);
-  const rpc = get(rpcId);
-  await rpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port, rpcId);
+  const rpc = get(targetRpcId);
+  if (!rpc) {
+    throw new Error(`rpc ${targetRpcId} not found`);
+  }
+  await rpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port, sourceRpcId);
 };
 
 // todo dispose the rpc by rpc id
@@ -7200,21 +7184,21 @@ const commandMap = {
   'ElectronWebContentsView.createWebContentsView': createWebContentsView,
   'ElectronWebContentsView.disposeWebContentsView': disposeWebContentsView,
   'ElectronWebContentsViewFunctions.addToWindow': addToWindow,
-  'ElectronWebContentsViewFunctions.backward': backward,
-  'ElectronWebContentsViewFunctions.cancelNavigation': cancelNavigation,
-  'ElectronWebContentsViewFunctions.copyImageAt': copyImageAt,
-  'ElectronWebContentsViewFunctions.focus': focus,
-  'ElectronWebContentsViewFunctions.forward': forward,
-  'ElectronWebContentsViewFunctions.getStats': getStats$1,
+  'ElectronWebContentsViewFunctions.backward': wrapBrowserViewCommand(backward),
+  'ElectronWebContentsViewFunctions.cancelNavigation': wrapBrowserViewCommand(cancelNavigation),
+  'ElectronWebContentsViewFunctions.copyImageAt': wrapBrowserViewCommand(copyImageAt),
+  'ElectronWebContentsViewFunctions.focus': wrapBrowserViewCommand(focus),
+  'ElectronWebContentsViewFunctions.forward': wrapBrowserViewCommand(forward),
+  'ElectronWebContentsViewFunctions.getStats': wrapBrowserViewCommand(getStats$1),
   'ElectronWebContentsViewFunctions.hide': hide,
-  'ElectronWebContentsViewFunctions.inspectElement': inspectElement,
-  'ElectronWebContentsViewFunctions.openDevtools': openDevtools,
-  'ElectronWebContentsViewFunctions.reload': reload,
-  'ElectronWebContentsViewFunctions.resizeBrowserView': resizeBrowserView,
-  'ElectronWebContentsViewFunctions.setBackgroundColor': setBackgroundColor,
-  'ElectronWebContentsViewFunctions.setFallthroughKeyBindings': setFallThroughKeyBindings,
-  'ElectronWebContentsViewFunctions.setIframeSrc': setIframeSrc,
-  'ElectronWebContentsViewFunctions.setIframeSrcFallback': setIframeSrcFallback,
+  'ElectronWebContentsViewFunctions.inspectElement': wrapBrowserViewCommand(inspectElement),
+  'ElectronWebContentsViewFunctions.openDevtools': wrapBrowserViewCommand(openDevtools),
+  'ElectronWebContentsViewFunctions.reload': wrapBrowserViewCommand(wrapBrowserViewCommand(reload)),
+  'ElectronWebContentsViewFunctions.resizeBrowserView': wrapBrowserViewCommand(resizeBrowserView),
+  'ElectronWebContentsViewFunctions.setBackgroundColor': wrapBrowserViewCommand(setBackgroundColor),
+  'ElectronWebContentsViewFunctions.setFallthroughKeyBindings': wrapBrowserViewCommand(setFallThroughKeyBindings),
+  'ElectronWebContentsViewFunctions.setIframeSrc': wrapBrowserViewCommand(setIframeSrc),
+  'ElectronWebContentsViewFunctions.setIframeSrcFallback': wrapBrowserViewCommand(setIframeSrcFallback),
   'ElectronWebContentsViewFunctions.show': show,
   'ElectronWindow.executeWebContentsFunction': executeWebContentsFunction,
   'ElectronWindow.executeWindowFunction': executeWindowFunction,
@@ -7224,7 +7208,7 @@ const commandMap = {
   'Exit.exit': exit,
   'GetWindowId.getWindowId': getWindowId,
   'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
-  'IpcParent.create': create$2,
+  'IpcParent.create': create$1,
   'OpenExternal.openExternal': openExternal,
   'Process.getArgv': getArgv,
   'Process.getChromeVersion': getChromeVersion,
@@ -7692,7 +7676,7 @@ const ElectronWindowProcessExplorer_ipc = {
 
 const name$c = 'IpcParent';
 const Commands$c = {
-  create: create$2
+  create: create$1
 };
 
 const IpcParent_ipc = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "",
   "keywords": [
     "lvce-editor",