@lvce-editor/main-process 3.0.0 → 3.1.0

package/dist/mainProcessMain.js

@@ -4,15 +4,15 @@ import process$1 from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
 import { spawn } from 'node:child_process';
-import { MessageChannel } from 'node:worker_threads';
+import { Console } from 'node:console';
 import { createWriteStream, readFileSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
 import * as NodePath from 'node:path';
 import { dirname } from 'node:path';
 import require$$1 from 'tty';
 import require$$1$1 from 'util';
 import require$$0 from 'os';
-import { tmpdir, homedir } from 'node:os';
-import { Console } from 'node:console';
+import { MessageChannel } from 'node:worker_threads';
 
 function escapeStringRegexp(string) {
   if (typeof string !== 'string') {
@@ -779,7 +779,7 @@ const getNewLineIndex$2 = (string, startIndex = undefined) => {
 
 // TODO disable logging via environment variable, don't enable logging during tests
 
-const state$7 = {
+const state$6 = {
   console: undefined
 };
 const createConsole = () => {
@@ -789,8 +789,8 @@ const createConsole = () => {
   return logger;
 };
 const getOrCreateLogger = () => {
-  state$7.console ||= createConsole();
-  return state$7.console;
+  state$6.console ||= createConsole();
+  return state$6.console;
 };
 const info = (...args) => {
   const logger = getOrCreateLogger();
@@ -2331,7 +2331,7 @@ const IpcParentWithElectronMessagePort$1 = {
   signal: signal$2,
   wrap: wrap$7
 };
-const Exit$1 = 1;
+const Exit = 1;
 const Error$2 = 2;
 const Message$1 = 3;
 const getFirstUtilityProcessEvent = async utilityProcess => {
@@ -2366,7 +2366,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   };
   const handleExit = event => {
     cleanup({
-      type: Exit$1,
+      type: Exit,
       event,
       stdout,
       stderr
@@ -2421,7 +2421,7 @@ const create$6 = async ({
     stdout,
     stderr
   } = await getFirstUtilityProcessEvent(childProcess);
-  if (type === Exit$1) {
+  if (type === Exit) {
     throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
   }
   // @ts-ignore
@@ -2535,7 +2535,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     };
     const handleExit = event => {
       cleanup({
-        type: Exit$1,
+        type: Exit,
         event,
         stdout,
         stderr
@@ -2590,7 +2590,7 @@ const create$2$2 = async ({
       event,
       stderr
     } = await getFirstNodeChildProcessEvent(childProcess);
-    if (type === Exit$1) {
+    if (type === Exit) {
       throw new ChildProcessError(stderr);
     }
     if (type === Error$2) {
@@ -2654,7 +2654,7 @@ const fixNodeWorkerParameters = value => {
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
     message: Message$1,
-    exit: Exit$1,
+    exit: Exit,
     error: Error$2
   });
 };
@@ -2688,7 +2688,7 @@ const create$1$2 = async ({
     type,
     event
   } = await getFirstNodeWorkerEvent(worker);
-  if (type === Exit$1) {
+  if (type === Exit) {
     throw new IpcError(`Worker exited before ipc connection was established`);
   }
   if (type === Error$2) {
@@ -2934,7 +2934,7 @@ const resolve = (id, response) => {
   fn(response);
   remove$2(id);
 };
-const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
@@ -2956,7 +2956,7 @@ const getStack = prettyError => {
   return stackString;
 };
 const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND$1) {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
       message: error.message,
@@ -3112,14 +3112,14 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
-let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
+class CommandNotFoundError extends Error {
   constructor(command) {
     super(`Command not found ${command}`);
     this.name = 'CommandNotFoundError';
   }
-};
+}
 const commands = Object.create(null);
-const register$1 = commandMap => {
+const register = commandMap => {
   Object.assign(commands, commandMap);
 };
 const getCommand = key => {
@@ -3128,7 +3128,7 @@ const getCommand = key => {
 const execute$1 = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new CommandNotFoundError$1(command);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -3191,7 +3191,7 @@ const create$k = async ({
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
@@ -3216,7 +3216,7 @@ const create$i = async ({
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const rawIpc = await IpcParentWithElectronUtilityProcess$1$1.create({
     env,
     argv,
@@ -3243,7 +3243,7 @@ const create$h = async ({
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const ipc = IpcChildWithRendererProcess2$1.wrap(webContents);
   if (requiresSocket) {
     // @ts-ignore
@@ -3411,7 +3411,7 @@ const launchSharedProcess = async ({
   return sharedProcessRpc;
 };
 
-const state$6 = {
+const state$5 = {
   /**
    * @type {any}
    */
@@ -3422,14 +3422,14 @@ const getOrCreate = async ({
   env = {},
   method
 }) => {
-  if (!state$6.promise) {
+  if (!state$5.promise) {
     // @ts-ignore
-    state$6.promise = launchSharedProcess({
+    state$5.promise = launchSharedProcess({
       env,
       method
     });
   }
-  return state$6.promise;
+  return state$5.promise;
 };
 const send$1 = async (method, ...params) => {
   const rpc = await getOrCreate({
@@ -4557,14 +4557,14 @@ const createTitleBar = items => {
 
 const PHASE_DEFAULT = 0;
 const PHASE_SHUTDOWN = -1;
-const state$5 = {
+const state$4 = {
   phase: PHASE_DEFAULT
 };
 const isShutDown = () => {
-  return state$5.phase === PHASE_SHUTDOWN;
+  return state$4.phase === PHASE_SHUTDOWN;
 };
 const setShutDown = () => {
-  state$5.phase = PHASE_SHUTDOWN;
+  state$4.phase = PHASE_SHUTDOWN;
 };
 
 // TODO move this function to shared process
@@ -4869,21 +4869,21 @@ const BeforeInputEvent = 'before-input-event';
 const Allow = 'allow';
 const Deny = 'deny';
 
-const state$4 = {
+const state$3 = {
   canceled: Object.create(null),
   fallThroughKeyBindings: [],
   views: Object.create(null)
 };
 const add$1 = (id, browserWindow, view) => {
   // state
-  state$4.views[id] = {
+  state$3.views[id] = {
     browserWindow,
     view
   };
 };
 const hasWebContents = id => {
   number(id);
-  return id in state$4.views;
+  return id in state$3.views;
 };
 /**
  *
@@ -4891,19 +4891,19 @@ const hasWebContents = id => {
  * @returns {{browserWindow: Electron.BrowserWindow, view: Electron.WebContentsView}}
  */
 const get$3 = id => {
-  return state$4.views[id];
+  return state$3.views[id];
 };
 const remove$1 = id => {
-  delete state$4.views[id];
+  delete state$3.views[id];
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  state$4.fallThroughKeyBindings = fallthroughKeyBindings;
+  state$3.fallThroughKeyBindings = fallthroughKeyBindings;
 };
 const getFallthroughKeyBindings = () => {
-  return state$4.fallThroughKeyBindings;
+  return state$3.fallThroughKeyBindings;
 };
 const setCanceled = id => {
-  state$4.canceled[id] = true;
+  state$3.canceled[id] = true;
 };
 
 const shouldAllowNavigation = webContentsId => {
@@ -5065,197 +5065,6 @@ const {
   argv
 } = process;
 
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const E_MODULE_NOT_FOUND = 'E_MODULE_NOT_FOUND';
-
-class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`command ${id} not found`);
-    this.name = 'CommandNotFoundError';
-    // @ts-ignore
-    this.code = E_COMMAND_NOT_FOUND;
-  }
-}
-
-const App = 1;
-const AppWindow = 2;
-const Beep = 3;
-const Developer = 4;
-const Dialog = 5;
-const ElectronWindowProcessExplorer = 6;
-const Window = 7;
-const ElectronShell = 8;
-const ElectronPowerSaveBlocker = 9;
-const ElectronSafeStorage = 10;
-const ElectronContentTracing = 11;
-const ElectronNetLog = 12;
-const ElectronBrowserView = 13;
-const ElectronBrowserViewQuickPick = 14;
-const ElectronContextMenu = 16;
-const ElectronClipBoard = 17;
-const ElectronApplicationMenu = 18;
-const Process = 19;
-const ElectronNet = 20;
-const ElectronBrowserViewSuggestions = 21;
-const CreatePidMap = 22;
-const OpenExternal$1 = 23;
-const Platform = 25;
-const GetWindowId = 26;
-const DesktopCapturer = 27;
-const Trash = 28;
-const IpcParent = 29;
-const Crash = 30;
-const Exit = 31;
-const ElectronScreen = 32;
-const TemporaryMessagePort = 34;
-const ElectronWebContents = 35;
-const ElectronWebContentsView = 36;
-const ElectronWebContentsViewFunctions = 37;
-const CreateMessagePort = 38;
-const HandleElectronMessagePort = 39;
-const ElectronSession = 40;
-
-const getPrefix = commandId => {
-  return commandId.slice(0, commandId.indexOf('.'));
-};
-const getModuleId = commandId => {
-  const prefix = getPrefix(commandId);
-  switch (prefix) {
-    case 'App':
-    case 'ElectronApp':
-      return App;
-    case 'AppWindow':
-      return AppWindow;
-    case 'Beep':
-      return Beep;
-    case 'Crash':
-      return Crash;
-    case 'CreateMessagePort':
-      return CreateMessagePort;
-    case 'CreatePidMap':
-      return CreatePidMap;
-    case 'DesktopCapturer':
-      return DesktopCapturer;
-    case 'ElectronApplicationMenu':
-      return ElectronApplicationMenu;
-    case 'ElectronBeep':
-      return Beep;
-    case 'ElectronBrowserView':
-      return ElectronBrowserView;
-    case 'ElectronBrowserViewQuickPick':
-      return ElectronBrowserViewQuickPick;
-    case 'ElectronBrowserViewSuggestions':
-      return ElectronBrowserViewSuggestions;
-    case 'ElectronClipBoard':
-      return ElectronClipBoard;
-    case 'ElectronContentTracing':
-      return ElectronContentTracing;
-    case 'ElectronContextMenu':
-      return ElectronContextMenu;
-    case 'ElectronDeveloper':
-      return Developer;
-    case 'ElectronDialog':
-      return Dialog;
-    case 'ElectronNet':
-      return ElectronNet;
-    case 'ElectronNetLog':
-      return ElectronNetLog;
-    case 'ElectronPowerSaveBlocker':
-      return ElectronPowerSaveBlocker;
-    case 'ElectronSafeStorage':
-      return ElectronSafeStorage;
-    case 'ElectronScreen':
-      return ElectronScreen;
-    case 'ElectronSession':
-      return ElectronSession;
-    case 'ElectronShell':
-      return ElectronShell;
-    case 'ElectronWebContents':
-      return ElectronWebContents;
-    case 'ElectronWebContentsView':
-      return ElectronWebContentsView;
-    case 'ElectronWebContentsViewFunctions':
-      return ElectronWebContentsViewFunctions;
-    case 'ElectronWindow':
-      return Window;
-    case 'ElectronWindowProcessExplorer':
-      return ElectronWindowProcessExplorer;
-    case 'Exit':
-      return Exit;
-    case 'GetWindowId':
-      return GetWindowId;
-    case 'HandleElectronMessagePort':
-      return HandleElectronMessagePort;
-    case 'IpcParent':
-      return IpcParent;
-    case 'OpenExternal':
-      return OpenExternal$1;
-    case 'Platform':
-      return Platform;
-    case 'Process':
-      return Process;
-    case 'TemporaryMessagePort':
-      return TemporaryMessagePort;
-    case 'Trash':
-      return Trash;
-    default:
-      throw new CommandNotFoundError(commandId);
-  }
-};
-
-const state$3 = {
-  commands: Object.create(null),
-  async load(moduleId) {},
-  pendingModules: Object.create(null)
-};
-const initializeModule = module => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = `${module.name}.${key}`;
-        register(actualKey, value);
-      } else {
-        register(key, value);
-      }
-    }
-    return;
-  }
-  throw new Error(`module ${module.name || '<unnamed module>'} is missing commands`);
-};
-const getOrLoadModule = moduleId => {
-  if (!state$3.pendingModules[moduleId]) {
-    const importPromise = state$3.load(moduleId);
-    state$3.pendingModules[moduleId] = importPromise.then(initializeModule);
-  }
-  return state$3.pendingModules[moduleId];
-};
-const loadCommand = command => getOrLoadModule(getModuleId(command));
-const register = (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$3.commands)) {
-    if (hasThrown.has(command)) {
-      return;
-    }
-    hasThrown.add(command);
-    throw new Error(`Command did not register "${command}"`);
-  }
-  return execute(command, ...args);
-};
-const execute = (command, ...args) => {
-  if (command in state$3.commands) {
-    return state$3.commands[command](...args);
-  }
-  return loadThenExecute(command, ...args);
-};
-const setLoad = load => {
-  state$3.load = load;
-};
-
 const ClipBoardRead = 'clipboard-read';
 const ClipBoardSanitizedWrite = 'clipboard-sanitized-write';
 const FullScreen = 'fullscreen';
@@ -5704,6 +5513,105 @@ const stopRecording = () => {
   return contentTracing.stopRecording();
 };
 
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    promise,
+    reject: _reject,
+    resolve: _resolve
+  };
+};
+
+const getElectronCallbacks = () => {
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  const handleClick = menuItem => {
+    resolve({
+      data: menuItem,
+      type: 'click'
+    });
+  };
+  const handleClose = () => {
+    resolve({
+      data: undefined,
+      type: 'close'
+    });
+  };
+  return {
+    handleClick,
+    handleClose,
+    promise
+  };
+};
+
+const getElectronMenuItems = (menuItems, click) => {
+  const template = [];
+  for (const menuItem of menuItems) {
+    // @ts-ignore
+    template.push({
+      ...menuItem,
+      click
+    });
+  }
+  return template;
+};
+
+const openContextMenu = async (menuItems, x, y) => {
+  array(menuItems);
+  number(x);
+  number(y);
+  const {
+    handleClick,
+    handleClose,
+    promise
+  } = getElectronCallbacks();
+  const template = getElectronMenuItems(menuItems, handleClick);
+  const menu = Menu.buildFromTemplate(template);
+  // TODO pass window id
+  const window = BrowserWindow.getFocusedWindow();
+  if (!window) {
+    return {
+      data: undefined,
+      type: 'close'
+    };
+  }
+  menu.popup({
+    callback: handleClose,
+    window,
+    x,
+    y
+  });
+  const event = await promise;
+  // @ts-ignore
+  if (event.type === 'click') {
+    return {
+      // @ts-ignore
+      data: event.data.label,
+      type: 'click'
+    };
+  }
+  // @ts-ignore
+  if (event.type === 'close') {
+    return {
+      data: undefined,
+      type: 'close'
+    };
+  }
+};
+
 const getPerformanceEntries = () => {
   const entries = getEntries();
   const {
@@ -6992,6 +6900,13 @@ const printPrettyError = (prettyError, prefix = '') => {
   error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
 };
 
+const execute = (method, ...params) => {
+  const fn = commandMapRef[method];
+  if (!fn) {
+    throw new Error(`command not found: ${method}`);
+  }
+  return fn(...params);
+};
 const logError = (error, prettyError) => {
   printPrettyError(prettyError, '[main-process] ');
 };
@@ -7299,6 +7214,7 @@ const commandMap = {
   'ElectronBeep.beep': beep,
   'ElectronContentTracing.startRecording': startRecording,
   'ElectronContentTracing.stopRecording': stopRecording,
+  'ElectronContextMenu.openContextMenu': openContextMenu,
   'ElectronDeveloper.crashMainProcess': crashMainProcess,
   'ElectronDeveloper.getPerformanceEntries': getPerformanceEntries,
   'ElectronDialog.showMessageBox': showMessageBox,
@@ -7369,88 +7285,6 @@ const commandMap = {
   'Trash.trash': trash
 };
 
-class ModuleNotFoundError extends Error {
-  constructor(id) {
-    super(`Module ${id} not found`);
-    this.name = 'ModuleNotFoundError';
-    // @ts-ignore
-    this.code = E_MODULE_NOT_FOUND;
-  }
-}
-
-const load = async moduleId => {
-  switch (moduleId) {
-    case App:
-      return Promise.resolve().then(function () { return App_ipc; });
-    case AppWindow:
-      return Promise.resolve().then(function () { return AppWindow_ipc; });
-    case Beep:
-      return Promise.resolve().then(function () { return Beep_ipc; });
-    case Crash:
-      return Promise.resolve().then(function () { return Crash_ipc; });
-    case CreateMessagePort:
-      return Promise.resolve().then(function () { return CreateMessagePort_ipc; });
-    case CreatePidMap:
-      return Promise.resolve().then(function () { return CreatePidMap_ipc; });
-    case DesktopCapturer:
-      return Promise.resolve().then(function () { return DesktopCapturer_ipc; });
-    case Developer:
-      return Promise.resolve().then(function () { return ElectronDeveloper_ipc; });
-    case Dialog:
-      return Promise.resolve().then(function () { return ElectronDialog_ipc; });
-    case ElectronApplicationMenu:
-      return Promise.resolve().then(function () { return ElectronApplicationMenu_ipc; });
-    case ElectronClipBoard:
-      return Promise.resolve().then(function () { return ElectronClipBoard_ipc; });
-    case ElectronContentTracing:
-      return Promise.resolve().then(function () { return ElectronContentTracing_ipc; });
-    case ElectronContextMenu:
-      return Promise.resolve().then(function () { return ElectronContextMenu_ipc; });
-    case ElectronNet:
-      return Promise.resolve().then(function () { return ElectronNet_ipc; });
-    case ElectronNetLog:
-      return Promise.resolve().then(function () { return ElectronNetLog_ipc; });
-    case ElectronPowerSaveBlocker:
-      return Promise.resolve().then(function () { return ElectronPowerSaveBlocker_ipc; });
-    case ElectronSafeStorage:
-      return Promise.resolve().then(function () { return ElectronSafeStorage_ipc; });
-    case ElectronScreen:
-      return Promise.resolve().then(function () { return ElectronScreen_ipc; });
-    case ElectronSession:
-      return Promise.resolve().then(function () { return ElectronSession_ipc; });
-    case ElectronShell:
-      return Promise.resolve().then(function () { return ElectronShell_ipc; });
-    case ElectronWebContents:
-      return Promise.resolve().then(function () { return ElectronWebContents_ipc; });
-    case ElectronWebContentsView:
-      return Promise.resolve().then(function () { return ElectronWebContentsView_ipc; });
-    case ElectronWebContentsViewFunctions:
-      return Promise.resolve().then(function () { return ElectronWebContentsViewFunctions_ipc; });
-    case ElectronWindowProcessExplorer:
-      return Promise.resolve().then(function () { return ElectronWindowProcessExplorer_ipc; });
-    case Exit:
-      return Promise.resolve().then(function () { return Exit_ipc; });
-    case GetWindowId:
-      return Promise.resolve().then(function () { return GetWindowId_ipc; });
-    case HandleElectronMessagePort:
-      return Promise.resolve().then(function () { return HandleElectronMessagePort_ipc; });
-    case IpcParent:
-      return Promise.resolve().then(function () { return IpcParent_ipc; });
-    case OpenExternal$1:
-      return Promise.resolve().then(function () { return OpenExternal_ipc; });
-    case Process:
-      return Promise.resolve().then(function () { return Process_ipc; });
-    case TemporaryMessagePort:
-      return Promise.resolve().then(function () { return TemporaryMessagePort_ipc; });
-    case Trash:
-      return Promise.resolve().then(function () { return Trash_ipc; });
-    case Window:
-      return Promise.resolve().then(function () { return ElectronWindow_ipc; });
-    default:
-      throw new ModuleNotFoundError(moduleId);
-  }
-};
-
 const setStackTraceLimit = value => {
   if (Error.stackTraceLimit && Error.stackTraceLimit < value) {
     Error.stackTraceLimit = value;
@@ -7465,518 +7299,7 @@ const main = async () => {
   on$1('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor);
   // workaround for https://github.com/electron/electron/issues/36526
   on$1('unhandledRejection', handleUnhandledRejection);
-  setLoad(load);
   await hydrate(isLinux, chromeUserDataPath, argv);
 };
 
 main();
-
-const name$w = 'App';
-const Commands$w = {};
-
-const App_ipc = {
-	__proto__: null,
-	Commands: Commands$w,
-	name: name$w
-};
-
-const name$v = 'AppWindow';
-const Commands$v = {
-  createAppWindow: createAppWindow
-};
-
-const AppWindow_ipc = {
-	__proto__: null,
-	Commands: Commands$v,
-	name: name$v
-};
-
-const name$u = 'Beep';
-const Commands$u = {
-  beep: beep$1
-};
-
-const Beep_ipc = {
-	__proto__: null,
-	Commands: Commands$u,
-	name: name$u
-};
-
-const name$t = 'Crash';
-const Commands$t = {
-  crashMainProcess: crashMainProcess$1
-};
-
-const Crash_ipc = {
-	__proto__: null,
-	Commands: Commands$t,
-	name: name$t
-};
-
-const name$s = 'CreateMessagePort';
-const Commands$s = {
-  createMessagePort: createMessagePort
-};
-
-const CreateMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$s,
-	name: name$s
-};
-
-const name$r = 'CreatePidMap';
-const Commands$r = {
-  createPidMap: createPidMap
-};
-
-const CreatePidMap_ipc = {
-	__proto__: null,
-	Commands: Commands$r,
-	name: name$r
-};
-
-const name$q = 'DesktopCapturer';
-const Commands$q = {
-  getSources: getSources
-};
-
-const DesktopCapturer_ipc = {
-	__proto__: null,
-	Commands: Commands$q,
-	name: name$q
-};
-
-const name$p = 'ElectronDeveloper';
-const Commands$p = {
-  crashMainProcess: crashMainProcess,
-  getPerformanceEntries: getPerformanceEntries
-};
-
-const ElectronDeveloper_ipc = {
-	__proto__: null,
-	Commands: Commands$p,
-	name: name$p
-};
-
-const name$o = 'ElectronDialog';
-const Commands$o = {
-  showMessageBox: showMessageBox,
-  showOpenDialog: showOpenDialog
-};
-
-const ElectronDialog_ipc = {
-	__proto__: null,
-	Commands: Commands$o,
-	name: name$o
-};
-
-const name$n = 'ElectronApplicationMenu';
-const Commands$n = {
-  setItems: setItems
-};
-
-const ElectronApplicationMenu_ipc = {
-	__proto__: null,
-	Commands: Commands$n,
-	name: name$n
-};
-
-const writeText = text => {
-  clipboard.writeText(text);
-};
-
-const name$m = 'ElectronClipBoard';
-const Commands$m = {
-  writeText: writeText
-};
-
-const ElectronClipBoard_ipc = {
-	__proto__: null,
-	Commands: Commands$m,
-	name: name$m
-};
-
-const name$l = 'ElectronContentTracing';
-const Commands$l = {
-  startRecording: startRecording,
-  stopRecording: stopRecording
-};
-
-const ElectronContentTracing_ipc = {
-	__proto__: null,
-	Commands: Commands$l,
-	name: name$l
-};
-
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
-  });
-  return {
-    promise,
-    reject: _reject,
-    resolve: _resolve
-  };
-};
-
-const getElectronCallbacks = () => {
-  const {
-    promise,
-    resolve
-  } = withResolvers();
-  const handleClick = menuItem => {
-    resolve({
-      data: menuItem,
-      type: 'click'
-    });
-  };
-  const handleClose = () => {
-    resolve({
-      data: undefined,
-      type: 'close'
-    });
-  };
-  return {
-    handleClick,
-    handleClose,
-    promise
-  };
-};
-
-const getElectronMenuItems = (menuItems, click) => {
-  const template = [];
-  for (const menuItem of menuItems) {
-    // @ts-ignore
-    template.push({
-      ...menuItem,
-      click
-    });
-  }
-  return template;
-};
-
-// @ts-ignore
-const openContextMenu = async (menuItems, x, y) => {
-  array(menuItems);
-  number(x);
-  number(y);
-  const {
-    handleClick,
-    handleClose,
-    promise
-  } = getElectronCallbacks();
-  const template = getElectronMenuItems(menuItems, handleClick);
-  const menu = Menu.buildFromTemplate(template);
-  const window = BrowserWindow.getFocusedWindow();
-  if (!window) {
-    return {
-      data: undefined,
-      type: 'close'
-    };
-  }
-  menu.popup({
-    callback: handleClose,
-    window,
-    x,
-    y
-  });
-  const event = await promise;
-  // @ts-ignore
-  if (event.type === 'click') {
-    return {
-      // @ts-ignore
-      data: event.data.label,
-      type: 'click'
-    };
-  }
-  // @ts-ignore
-  if (event.type === 'close') {
-    return {
-      data: undefined,
-      type: 'close'
-    };
-  }
-};
-
-const name$k = 'ElectronContextMenu';
-const Commands$k = {
-  openContextMenu: openContextMenu
-};
-
-const ElectronContextMenu_ipc = {
-	__proto__: null,
-	Commands: Commands$k,
-	name: name$k
-};
-
-const name$j = 'ElectronNet';
-const Commands$j = {
-  getJson: getJson
-};
-
-const ElectronNet_ipc = {
-	__proto__: null,
-	Commands: Commands$j,
-	name: name$j
-};
-
-const name$i = 'ElectronNetLog';
-const Commands$i = {
-  startLogging: startLogging,
-  stopLogging: stopLogging
-};
-
-const ElectronNetLog_ipc = {
-	__proto__: null,
-	Commands: Commands$i,
-	name: name$i
-};
-
-const name$h = 'ElectronPowerSaveBlocker';
-const Commands$h = {
-  start: start,
-  stop: stop
-};
-
-const ElectronPowerSaveBlocker_ipc = {
-	__proto__: null,
-	Commands: Commands$h,
-	name: name$h
-};
-
-const name$g = 'ElectronSafeStorage';
-const Commands$g = {
-  decrypt: decrypt,
-  encrypt: encrypt,
-  isEncryptionAvailable: isEncryptionAvailable
-};
-
-const ElectronSafeStorage_ipc = {
-	__proto__: null,
-	Commands: Commands$g,
-	name: name$g
-};
-
-const name$f = 'ElectronScreen';
-const Commands$f = {
-  getBounds: getBounds,
-  getHeight: getHeight,
-  getWidth: getWidth
-};
-
-const ElectronScreen_ipc = {
-	__proto__: null,
-	Commands: Commands$f,
-	name: name$f
-};
-
-const name$e = 'ElectronSession';
-const Commands$e = {
-  registerWebviewProtocol: registerWebviewProtocol
-};
-
-const ElectronSession_ipc = {
-	__proto__: null,
-	Commands: Commands$e,
-	name: name$e
-};
-
-const name$d = 'ElectronShell';
-const Commands$d = {
-  beep: beep$1,
-  openExternal: openExternal,
-  openPath: showItemInFolder,
-  showItemInFolder: showItemInFolder
-};
-
-const ElectronShell_ipc = {
-	__proto__: null,
-	Commands: Commands$d,
-	name: name$d
-};
-
-const name$c = 'ElectronWebContents';
-const Commands$c = {
-  callFunction: callFunction,
-  dispose: dispose$1,
-  getStats: getStats$1
-};
-
-const ElectronWebContents_ipc = {
-	__proto__: null,
-	Commands: Commands$c,
-	name: name$c
-};
-
-const name$b = 'ElectronWebContentsView';
-const Commands$b = {
-  attachEventListeners: attachEventListeners,
-  createWebContentsView: createWebContentsView,
-  disposeWebContentsView: disposeWebContentsView
-};
-
-const ElectronWebContentsView_ipc = {
-	__proto__: null,
-	Commands: Commands$b,
-	name: name$b
-};
-
-const name$a = 'ElectronWebContentsViewFunctions';
-const Commands$a = {
-  addToWindow: addToWindow,
-  backward: wrapBrowserViewCommand(backward),
-  cancelNavigation: wrapBrowserViewCommand(cancelNavigation),
-  copyImageAt: wrapBrowserViewCommand(copyImageAt),
-  executeJavaScript: wrapBrowserViewCommand(executeJavaScript),
-  focus: wrapBrowserViewCommand(focus),
-  forward: wrapBrowserViewCommand(forward),
-  getDomTree: wrapBrowserViewCommand(getDomTree),
-  getStats: wrapBrowserViewCommand(getStats),
-  hide: hide,
-  insertCss: wrapBrowserViewCommand(insertCss),
-  insertJavaScript: wrapBrowserViewCommand(executeJavaScript),
-  inspectElement: wrapBrowserViewCommand(inspectElement),
-  openDevtools: wrapBrowserViewCommand(openDevtools),
-  reload: wrapBrowserViewCommand(reload),
-  resizeBrowserView: wrapBrowserViewCommand(resizeBrowserView),
-  setBackgroundColor: wrapBrowserViewCommand(setBackgroundColor),
-  setFallthroughKeyBindings: setFallThroughKeyBindings,
-  setIframeSrc: wrapBrowserViewCommand(setIframeSrc),
-  setIframeSrcFallback: wrapBrowserViewCommand(setIframeSrcFallback),
-  show: show
-};
-
-const ElectronWebContentsViewFunctions_ipc = {
-	__proto__: null,
-	Commands: Commands$a,
-	name: name$a
-};
-
-const name$9 = 'ElectronWindowProcessExplorer';
-const Commands$9 = {
-  open2: open2
-};
-
-const ElectronWindowProcessExplorer_ipc = {
-	__proto__: null,
-	Commands: Commands$9,
-	name: name$9
-};
-
-const name$8 = 'Exit';
-const Commands$8 = {
-  exit: exit
-};
-
-const Exit_ipc = {
-	__proto__: null,
-	Commands: Commands$8,
-	name: name$8
-};
-
-const name$7 = 'GetWindowId';
-const Commands$7 = {
-  getWindowId: getWindowId
-};
-
-const GetWindowId_ipc = {
-	__proto__: null,
-	Commands: Commands$7,
-	name: name$7
-};
-
-const name$6 = 'HandleElectronMessagePort';
-const Commands$6 = {
-  handleElectronMessagePort: handleElectronMessagePort
-};
-
-const HandleElectronMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$6,
-	name: name$6
-};
-
-const name$5 = 'IpcParent';
-const Commands$5 = {
-  create: create$1
-};
-
-const IpcParent_ipc = {
-	__proto__: null,
-	Commands: Commands$5,
-	name: name$5
-};
-
-const name$4 = 'OpenExternal';
-const Commands$4 = {
-  openExternal: openExternal
-};
-
-const OpenExternal_ipc = {
-	__proto__: null,
-	Commands: Commands$4,
-	name: name$4
-};
-
-const name$3 = 'Process';
-const Commands$3 = {
-  getArgv: getArgv,
-  getChromeVersion: getChromeVersion,
-  getElectronVersion: getElectronVersion,
-  getNodeVersion: getNodeVersion,
-  getPid: getPid,
-  getV8Version: getV8Version
-};
-
-const Process_ipc = {
-	__proto__: null,
-	Commands: Commands$3,
-	name: name$3
-};
-
-const name$2 = 'TemporaryMessagePort';
-const Commands$2 = {
-  createPortTuple: createPortTuple,
-  dispose: dispose,
-  sendTo: sendTo
-};
-
-const TemporaryMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$2,
-	name: name$2
-};
-
-const name$1 = 'Trash';
-const Commands$1 = {
-  trash: trash
-};
-
-const Trash_ipc = {
-	__proto__: null,
-	Commands: Commands$1,
-	name: name$1
-};
-
-const name = 'ElectronWindow';
-const Commands = {
-  executeWebContentsFunction: executeWebContentsFunction,
-  executeWindowFunction: executeWindowFunction,
-  getFocusedWindowId: getFocusedWindowId,
-  getZoom: getZoom
-};
-
-const ElectronWindow_ipc = {
-	__proto__: null,
-	Commands,
-	name
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "keywords": [
     "lvce-editor",
     "electron"