@lvce-editor/main-process 2.4.0 → 2.6.0

package/dist/mainProcessMain.js

@@ -1,10 +1,11 @@
 import * as Electron from 'electron';
-import Electron__default, { dialog, app, clipboard, BrowserWindow, MessageChannelMain, Menu, shell, desktopCapturer, contentTracing, net, netLog, powerSaveBlocker, safeStorage, screen, WebContentsView, webContents } from 'electron';
+import Electron__default, { dialog, app, clipboard, BrowserWindow, MessageChannelMain, Menu, shell, desktopCapturer, contentTracing, net, netLog, powerSaveBlocker, safeStorage, screen, webContents, WebContentsView } from 'electron';
 import process$1 from 'node:process';
 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`);
-};
-
-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 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}`);
-  }
+  return state$2.session;
 };
-
-/**
- *
- * @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 set = value => {
+  state$2.session = value;
 };
 
-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 => {
@@ -5893,6 +5805,53 @@ const getBounds = () => {
   };
 };
 
+const disposeWebContents = webContents => {
+  if (webContents.close) {
+    // electron v22
+    webContents.close();
+    // @ts-ignore
+  } else if (webContents.destroy) {
+    // older versions of electron
+    // @ts-ignore
+    webContents.destroy();
+  }
+};
+
+const getStats$1 = webContentsId => {
+  number(webContentsId);
+  const contents = webContents.fromId(webContentsId);
+  if (!contents) {
+    return undefined;
+  }
+  const canGoBack = contents.navigationHistory.canGoBack();
+  const canGoForward = contents.navigationHistory.canGoForward();
+  const url = contents.getURL();
+  const title = contents.getTitle();
+  return {
+    canGoBack,
+    canGoForward,
+    url,
+    title
+  };
+};
+const dispose$1 = webContentsId => {
+  number(webContentsId);
+  const contents = webContents.fromId(webContentsId);
+  if (!contents) {
+    return;
+  }
+  disposeWebContents(contents);
+};
+const callFunction = (webContentsId, functionName, ...args) => {
+  number(webContentsId);
+  string(functionName);
+  const contents = webContents.fromId(webContentsId);
+  if (!contents) {
+    return;
+  }
+  contents[functionName](...args);
+};
+
 const KeyDown = 'keyDown';
 
 const Backspace$1 = 'Backspace';
@@ -6596,7 +6555,7 @@ const filter = {
   urls: ['<all_urls>']
 };
 
-const state$1 = {
+const state = {
   session: undefined
 };
 const isAllowedPermission = permission => {
@@ -6629,24 +6588,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
@@ -6724,15 +6675,6 @@ const wrapBrowserViewCommand = fn => {
   };
   return wrappedCommand;
 };
-
-/**
- *
- * @param {Electron.BrowserView} view
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- */
 const resizeBrowserView = (view, x, y, width, height) => {
   object(view);
   number(x);
@@ -6754,12 +6696,6 @@ const setIframeSrcFallback = async (view, code, message) => {
     }
   });
 };
-
-/**
- *
- * @param {Electron.BrowserView} view
- * @param {string} iframeSrc
- */
 const setIframeSrc = async (view, iframeSrc) => {
   try {
     object(view);
@@ -6775,21 +6711,12 @@ const setIframeSrc = async (view, iframeSrc) => {
     throw betterError;
   }
 };
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const focus = view => {
   const {
     webContents
   } = view;
   webContents.focus();
 };
-
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const openDevtools = view => {
   const {
     webContents
@@ -6797,43 +6724,25 @@ const openDevtools = view => {
   // TODO return promise that resolves once devtools are actually open
   webContents.openDevTools();
 };
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const reload = view => {
   const {
     webContents
   } = view;
   webContents.reload();
 };
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const forward = view => {
   const {
     webContents
   } = view;
-  webContents.goForward();
+  webContents.navigationHistory.goForward();
 };
-
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const backward = view => {
   // TODO return promise that resolves once devtools are actually open
   const {
     webContents
   } = view;
-  webContents.goBack();
+  webContents.navigationHistory.goBack();
 };
-
-/**
- *
- * @param {Electron.BrowserView} view
- */
 const cancelNavigation = view => {
   const {
     webContents
@@ -6841,8 +6750,8 @@ const cancelNavigation = view => {
   setCanceled(webContents.id);
   debug(`[main process] canceled navigation to ${webContents.getURL()}`);
   webContents.stop();
-  if (webContents.canGoBack()) {
-    webContents.goBack();
+  if (webContents.navigationHistory.canGoBack()) {
+    webContents.navigationHistory.goBack();
   }
 };
 const show = id => {
@@ -6929,7 +6838,7 @@ const setFallThroughKeyBindings = fallthroughKeyBindings => {
 /**
  * @param {Electron.BrowserView} view
  */
-const getStats$1 = view => {
+const getStats = view => {
   const {
     webContents
   } = view;
@@ -6945,7 +6854,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 +6904,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 +6971,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 +7112,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,14 +7128,17 @@ 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
-const dispose$1 = name => {
+const dispose = name => {
   string(name);
   const formattedName = formatUtilityProcessName(name);
   const utilityProcess = getByName(formattedName);
@@ -7196,25 +7185,28 @@ const commandMap = {
   'ElectronShell.openExternal': openExternal,
   'ElectronShell.openPath': openPath,
   'ElectronShell.showItemInFolder': showItemInFolder,
+  'ElectronWebContents.callFunction': callFunction,
+  'ElectronWebContents.dispose': dispose$1,
+  'ElectronWebContents.getStats': getStats$1,
   'ElectronWebContentsView.attachEventListeners': attachEventListeners,
   '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),
   '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 +7216,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,
@@ -7233,7 +7225,7 @@ const commandMap = {
   'Process.getPid': getPid,
   'Process.getV8Version': getV8Version,
   'TemporaryMessagePort.createPortTuple': createPortTuple,
-  'TemporaryMessagePort.dispose': dispose$1,
+  'TemporaryMessagePort.dispose': dispose,
   'TemporaryMessagePort.sendTo': sendTo,
   'TemporaryMessagePort.sendTo2': sendTo2,
   'Trash.trash': trash
@@ -7692,7 +7684,7 @@ const ElectronWindowProcessExplorer_ipc = {
 
 const name$c = 'IpcParent';
 const Commands$c = {
-  create: create$2
+  create: create$1
 };
 
 const IpcParent_ipc = {
@@ -7755,7 +7747,7 @@ const ElectronScreen_ipc = {
 const name$7 = 'TemporaryMessagePort';
 const Commands$7 = {
   createPortTuple: createPortTuple,
-  dispose: dispose$1,
+  dispose: dispose,
   sendTo: sendTo
 };
 
@@ -7765,61 +7757,10 @@ const TemporaryMessagePort_ipc = {
 	name: name$7
 };
 
-/**
- *
- * @param {Electron.WebContents} webContents
- */
-const disposeWebContents = webContents => {
-  if (webContents.close) {
-    // electron v22
-    webContents.close();
-    // @ts-ignore
-  } else if (webContents.destroy) {
-    // older versions of electron
-    // @ts-ignore
-    webContents.destroy();
-  }
-};
-
-const getStats = webContentsId => {
-  number(webContentsId);
-  const contents = webContents.fromId(webContentsId);
-  if (!contents) {
-    return undefined;
-  }
-  const canGoBack = contents.navigationHistory.canGoBack();
-  const canGoForward = contents.navigationHistory.canGoForward();
-  const url = contents.getURL();
-  const title = contents.getTitle();
-  return {
-    canGoBack,
-    canGoForward,
-    url,
-    title
-  };
-};
-const dispose = webContentsId => {
-  number(webContentsId);
-  const contents = webContents.fromId(webContentsId);
-  if (!contents) {
-    return;
-  }
-  disposeWebContents(contents);
-};
-const callFunction = (webContentsId, functionName, ...args) => {
-  number(webContentsId);
-  string(functionName);
-  const contents = webContents.fromId(webContentsId);
-  if (!contents) {
-    return;
-  }
-  contents[functionName](...args);
-};
-
 const name$6 = 'ElectronWebContents';
 const Commands$6 = {
-  dispose: dispose,
-  getStats: getStats,
+  dispose: dispose$1,
+  getStats: getStats$1,
   callFunction: callFunction
 };
 
@@ -7850,7 +7791,7 @@ const Commands$4 = {
   copyImageAt: wrapBrowserViewCommand(copyImageAt),
   focus: wrapBrowserViewCommand(focus),
   forward: wrapBrowserViewCommand(forward),
-  getStats: wrapBrowserViewCommand(getStats$1),
+  getStats: wrapBrowserViewCommand(getStats),
   hide: hide,
   inspectElement: wrapBrowserViewCommand(inspectElement),
   openDevtools: wrapBrowserViewCommand(openDevtools),

package/package.json

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