@lvce-editor/main-process 6.38.0 → 6.40.0

package/dist/mainProcessMain.js

@@ -2230,7 +2230,7 @@ const IpcChildWithNodeForkedProcess$1 = {
   signal: signal$7,
   wrap: wrap$d
 };
-const listen$3 = async () => {
+const listen$3$1 = async () => {
   const {
     parentPort
   } = await import('node:worker_threads');
@@ -2268,7 +2268,7 @@ const wrap$b = parentPort => {
 };
 const IpcChildWithNodeWorker$1 = {
   __proto__: null,
-  listen: listen$3,
+  listen: listen$3$1,
   signal: signal$5,
   wrap: wrap$b
 };
@@ -3115,7 +3115,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$2,
@@ -3124,7 +3124,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -3234,7 +3234,7 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
 
 const Two$1 = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two$1,
     method,
@@ -3242,7 +3242,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two$1,
@@ -3253,12 +3253,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -3275,7 +3275,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -3311,7 +3311,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -3342,7 +3342,7 @@ const handleIpc$1 = ipc => {
   }
 };
 
-const listen$2 = async (module, options) => {
+const listen$3 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
     module.signal(rawIpc);
@@ -3351,14 +3351,14 @@ const listen$2 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   messagePort,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
+  const ipc = await listen$3(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -3369,7 +3369,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   argv,
   commandMap,
   env,
@@ -3397,7 +3397,7 @@ const create$4 = async ({
   return rpc;
 };
 
-const create$3 = async ({
+const create$4 = async ({
   commandMap,
   requiresSocket,
   webContents
@@ -3482,7 +3482,7 @@ const trackUtilityProcess = (rawIpc, name) => {
 };
 
 const createElectronUtilityProcessRpc = async options => {
-  const rpc = await create$4(options);
+  const rpc = await create$5(options);
   const rpcWithRawIpc = rpc;
   trackUtilityProcess(rpcWithRawIpc.ipc?._rawIpc, options.name);
   return rpc;
@@ -3602,7 +3602,7 @@ const launchSharedProcess = async ({
     port2
   } = getPortTuple();
   await sharedProcessRpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2, MainProcess);
-  await create$5({
+  await create$6({
     commandMap: commandMapRef,
     messagePort: port1,
     requiresSocket: requiresSocket
@@ -4744,6 +4744,126 @@ const load = async (path, env = process.env) => {
   }
 };
 
+const create$3 = () => {
+  let pressedAt = -1;
+  let releasedAt = -1;
+  let controlCode = '';
+  const reset = () => {
+    pressedAt = -1;
+    releasedAt = -1;
+    controlCode = '';
+  };
+  const accept = (input, now) => {
+    if (!['ControlLeft', 'ControlRight'].includes(input.code) || input.alt || input.meta || input.shift || input.isComposing) {
+      reset();
+      return false;
+    }
+    if (input.isAutoRepeat) {
+      return false;
+    }
+    if (input.type === 'keyDown') {
+      if (pressedAt !== -1 || controlCode !== input.code || now - releasedAt > 400) {
+        reset();
+      }
+      controlCode = input.code;
+      pressedAt = now;
+      return false;
+    }
+    if (input.type !== 'keyUp' || controlCode !== input.code || pressedAt === -1 || now - pressedAt > 250) {
+      reset();
+      return false;
+    }
+    pressedAt = -1;
+    if (releasedAt !== -1 && now - releasedAt <= 400) {
+      reset();
+      return true;
+    }
+    releasedAt = now;
+    return false;
+  };
+  return {
+    accept,
+    reset
+  };
+};
+
+const windows = new Map();
+const setEnabled = (windowId, enabled) => {
+  windows.get(windowId)?.setEnabled(enabled);
+};
+const attach$d = (window, contents) => {
+  windows.get(window.id)?.attach(contents);
+};
+const listen$2 = (window, rpc) => {
+  const gesture = create$3();
+  const disposers = new Map();
+  let enabled = false;
+  let pending;
+  const reset = () => {
+    gesture.reset();
+    if (pending) {
+      clearImmediate(pending);
+      pending = undefined;
+    }
+  };
+  const attachContents = contents => {
+    if (disposers.has(contents)) {
+      return;
+    }
+    const handleInput = (_event, input) => {
+      if (!enabled || !window.isFocused()) {
+        reset();
+        return;
+      }
+      if (gesture.accept(input, performance.now())) {
+        // Deliver the key release before moving focus to another WebContents.
+        pending = setImmediate(() => {
+          pending = undefined;
+          if (enabled && !contents.isDestroyed() && contents.isFocused() && window.isFocused()) {
+            rpc.send('Window.handleBrowserFullWidthGesture');
+          }
+        });
+      }
+    };
+    const dispose = () => {
+      reset();
+      contents.off('before-input-event', handleInput);
+      contents.off('before-mouse-event', reset);
+      contents.off('blur', reset);
+      contents.off('focus', reset);
+      contents.off('destroyed', dispose);
+      disposers.delete(contents);
+    };
+    contents.on('before-input-event', handleInput);
+    contents.on('before-mouse-event', reset);
+    contents.on('blur', reset);
+    contents.on('focus', reset);
+    contents.once('destroyed', dispose);
+    disposers.set(contents, dispose);
+  };
+  windows.set(window.id, {
+    attach: attachContents,
+    setEnabled(value) {
+      reset();
+      enabled = value;
+    }
+  });
+  attachContents(window.webContents);
+  window.on('blur', reset);
+  const dispose = () => {
+    enabled = false;
+    reset();
+    for (const disposeContents of disposers.values()) {
+      disposeContents();
+    }
+    window.off('blur', reset);
+    window.off('closed', dispose);
+    windows.delete(window.id);
+  };
+  window.once('closed', dispose);
+  return dispose;
+};
+
 const closePreparationTimeout = 1000;
 const prepareClose = async rpc => {
   let timeout;
@@ -4997,7 +5117,7 @@ const get$2 = () => {
 };
 const registerWebviewProtocol = async port => {
   object(port);
-  const rpc = await create$5({
+  const rpc = await create$6({
     commandMap: {},
     messagePort: port,
     requiresSocket: requiresSocket
@@ -5118,12 +5238,16 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
   // window.setMenu(menu)
   window.setMenuBarVisibility(true);
   window.setAutoHideMenuBar(false);
-  const rpc = await create$3({
+  const rpc = await create$4({
     commandMap: commandMapRef,
     webContents: window.webContents
   });
   const disposeFullScreenListener = listen$1(window, rpc);
-  const handleWindowClose = createWindowCloseHandler(window, rpc, error => handleError(new VError(error, `Failed to prepare window close`)), disposeFullScreenListener);
+  const disposeBrowserGesture = listen$2(window, rpc);
+  const handleWindowClose = createWindowCloseHandler(window, rpc, error => handleError(new VError(error, `Failed to prepare window close`)), () => {
+    disposeBrowserGesture();
+    disposeFullScreenListener();
+  });
   window.on('close', handleWindowClose);
   await loadUrl(window, url);
 };
@@ -5373,32 +5497,47 @@ const getElectronCallbacks = () => {
   };
 };
 
-const getElectronMenuItems = (menuItems, click) => {
-  const template = [];
-  for (const menuItem of menuItems) {
-    // @ts-ignore
-    template.push({
+const editingActions = new Set(['undo', 'redo', 'cut', 'copy', 'paste', 'selectAll']);
+const getElectronMenuItems = (menuItems, click, contents) => {
+  return menuItems.map(menuItem => {
+    const {
+      role,
+      ...options
+    } = menuItem;
+    if (contents && editingActions.has(role)) {
+      return {
+        ...options,
+        click(item) {
+          if (!contents.isDestroyed()) contents[role]();
+          click(item);
+        }
+      };
+    }
+    return {
       ...menuItem,
       click
-    });
-  }
-  return template;
+    };
+  });
 };
 
-const openContextMenu = async (menuItems, x, y) => {
+const openContextMenu = async (menuItems, x, y, browserViewId) => {
   array(menuItems);
   number(x);
   number(y);
+  const origin = browserViewId === undefined ? undefined : get$4(browserViewId);
+  if (browserViewId !== undefined && (!origin || origin.view.webContents.isDestroyed())) return {
+    data: undefined,
+    type: 'close'
+  };
   const {
     handleClick,
     handleClose,
     promise
   } = getElectronCallbacks();
-  const template = getElectronMenuItems(menuItems, handleClick);
+  const template = getElectronMenuItems(menuItems, handleClick, origin?.view.webContents);
   const menu = Menu.buildFromTemplate(template);
-  // TODO pass window id
-  const window = BrowserWindow.getFocusedWindow();
-  if (!window) {
+  const window = origin?.browserWindow || BrowserWindow.getFocusedWindow();
+  if (!window || window.isDestroyed()) {
     return {
       data: undefined,
       type: 'close'
@@ -5721,6 +5860,10 @@ const executeWindowFunction = (browserWindowId, key) => {
   if (!browserWindow) {
     return;
   }
+  if (key === 'enableBrowserFullWidthGesture' || key === 'disableBrowserFullWidthGesture') {
+    setEnabled(browserWindowId, key === 'enableBrowserFullWidthGesture');
+    return;
+  }
   if (key === 'toggleDevtools') {
     toggleDevtools(browserWindow);
     return;
@@ -6911,6 +7054,11 @@ const getSession = () => {
 
 const attach$1 = (webContents, parentWebContents) => {
   let shouldRestoreParentFocus = false;
+  const cancel = () => {
+    shouldRestoreParentFocus = false;
+  };
+  parentWebContents.on('blur', cancel);
+  webContents.once('destroyed', () => parentWebContents.off('blur', cancel));
   webContents.on(DidStartNavigation, (_event, _url, _isInPlace, isMainFrame) => {
     if (!isMainFrame) {
       return;
@@ -6918,7 +7066,7 @@ const attach$1 = (webContents, parentWebContents) => {
     shouldRestoreParentFocus = parentWebContents.isFocused();
   });
   webContents.on(DidNavigate, () => {
-    if (!shouldRestoreParentFocus) {
+    if (!shouldRestoreParentFocus || parentWebContents.isDestroyed()) {
       return;
     }
     shouldRestoreParentFocus = false;
@@ -6980,6 +7128,7 @@ const attachEventListenersToWebContents = (webContentsId, webContents, browserWi
   if (webContentsWithEventListeners.has(webContents)) {
     return;
   }
+  attach$d(browserWindow, webContents);
   attach$1(webContents, browserWindow.webContents);
   attach(webContents);
   const values = Object.values(ElectronBrowserViewEventListeners);
@@ -7543,7 +7692,7 @@ const getWindowId = webContentsId => {
 
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await create$5({
+  const rpc = await create$6({
     commandMap: commandMapRef,
     messagePort: messagePort,
     requiresSocket: requiresSocket

package/package.json

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