@lvce-editor/main-process 6.41.2 → 6.43.0

package/dist/mainProcessMain.js

@@ -4813,8 +4813,8 @@ const create$3 = () => {
 };
 
 const windows = new Map();
-const setEnabled = (windowId, enabled) => {
-  windows.get(windowId)?.setEnabled(enabled);
+const setEnabled = (windowId, enabled, modifier = 'ctrl=twice') => {
+  windows.get(windowId)?.setEnabled(enabled, modifier);
 };
 const attach$e = (window, contents) => {
   windows.get(window.id)?.attach(contents);
@@ -4822,10 +4822,16 @@ const attach$e = (window, contents) => {
 const listen$2 = (window, rpc) => {
   const gesture = create$3();
   const disposers = new Map();
+  let modifier = 'ctrl=twice';
+  const heldControls = new Set();
+  let holdTimer;
   let enabled = false;
   let pending;
   const reset = () => {
     gesture.reset();
+    heldControls.clear();
+    clearTimeout(holdTimer);
+    holdTimer = undefined;
     if (pending) {
       clearImmediate(pending);
       pending = undefined;
@@ -4840,6 +4846,25 @@ const listen$2 = (window, rpc) => {
         reset();
         return;
       }
+      if (modifier === 'ctrl-hold') {
+        const isControl = input.code === 'ControlLeft' || input.code === 'ControlRight';
+        const wasHeld = heldControls.has(input.code);
+        if (isControl && input.type === 'keyDown') heldControls.add(input.code);
+        if (isControl && input.type === 'keyUp') heldControls.delete(input.code);
+        if (!isControl || input.type === 'keyUp' || input.alt || input.meta || input.shift || input.isComposing || heldControls.size !== 1) {
+          clearTimeout(holdTimer);
+          holdTimer = undefined;
+          return;
+        }
+        if (input.type !== 'keyDown' || input.isAutoRepeat || wasHeld) return;
+        holdTimer = setTimeout(() => {
+          holdTimer = undefined;
+          if (enabled && !contents.isDestroyed() && contents.isFocused() && window.isFocused()) {
+            rpc.send('Window.handleBrowserFullWidthGesture');
+          }
+        }, 300);
+        return;
+      }
       if (gesture.accept(input, performance.now())) {
         // Deliver the key release before moving focus to another WebContents.
         pending = setImmediate(() => {
@@ -4868,9 +4893,10 @@ const listen$2 = (window, rpc) => {
   };
   windows.set(window.id, {
     attach: attachContents,
-    setEnabled(value) {
+    setEnabled(value, nextModifier) {
       reset();
       enabled = value;
+      modifier = nextModifier;
     }
   });
   attachContents(window.webContents);
@@ -4891,17 +4917,17 @@ const listen$2 = (window, rpc) => {
 
 const closePreparationTimeout = 1000;
 const prepareClose = async rpc => {
-  let timeout;
+  const {
+    promise,
+    reject
+  } = Promise.withResolvers();
+  const timeout = setTimeout(() => {
+    reject(new Error(`Timed out preparing window close after ${closePreparationTimeout}ms`));
+  }, closePreparationTimeout);
   try {
-    await Promise.race([rpc.invoke('Window.prepareClose'), new Promise((_resolve, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(`Timed out preparing window close after ${closePreparationTimeout}ms`));
-      }, closePreparationTimeout);
-    })]);
+    await Promise.race([rpc.invoke('Window.prepareClose'), promise]);
   } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
+    clearTimeout(timeout);
   }
 };
 const createWindowCloseHandler = (window, rpc, onError, dispose = () => {}) => {
@@ -5281,6 +5307,72 @@ const beep$1 = () => {
   shell.beep();
 };
 
+const pending = new WeakMap();
+const stop$1 = view => {
+  pending.get(view)?.();
+  if (!view.webContents.isDestroyed()) view.webContents.stopFindInPage('clearSelection');
+};
+const find = (view, text, forward = true, matchCase = false, newSession = true) => {
+  pending.get(view)?.();
+  const {
+    webContents
+  } = view;
+  if (webContents.isDestroyed()) return Promise.resolve(undefined);
+  if (!text) {
+    stop$1(view);
+    return Promise.resolve({
+      activeMatchOrdinal: 0,
+      matches: 0
+    });
+  }
+  return new Promise((resolve, reject) => {
+    let requestId = 0;
+    const finish = result => {
+      clearTimeout(timeout);
+      webContents.off('found-in-page', onResult);
+      webContents.off('did-start-navigation', onNavigation);
+      webContents.off('destroyed', cancel);
+      webContents.off('render-process-gone', cancel);
+      pending.delete(view);
+      resolve(result);
+    };
+    const cancel = () => finish();
+    const onNavigation = (_event, _url, inPlace, mainFrame) => {
+      if (mainFrame && !inPlace) cancel();
+    };
+    const onResult = (_event, result) => {
+      if (result.requestId === requestId && result.finalUpdate) {
+        finish({
+          activeMatchOrdinal: result.activeMatchOrdinal,
+          matches: result.matches
+        });
+      }
+    };
+    const timeout = setTimeout(cancel, 10_000);
+    pending.set(view, cancel);
+    webContents.on('found-in-page', onResult);
+    webContents.on('did-start-navigation', onNavigation);
+    webContents.once('destroyed', cancel);
+    webContents.once('render-process-gone', cancel);
+    try {
+      // Electron maps findNext to Chromium's new_session option.
+      requestId = webContents.findInPage(text, {
+        findNext: newSession,
+        forward,
+        matchCase
+      });
+    } catch (error) {
+      clearTimeout(timeout);
+      webContents.off('found-in-page', onResult);
+      webContents.off('did-start-navigation', onNavigation);
+      webContents.off('destroyed', cancel);
+      webContents.off('render-process-gone', cancel);
+      pending.delete(view);
+      reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+};
+
 const handleTimeout = () => {
   throw new Error('oops');
 };
@@ -5884,13 +5976,13 @@ const toggleDevtools = browserWindow => {
 const toggleFullScreen = browserWindow => {
   browserWindow.setFullScreen(!browserWindow.isFullScreen());
 };
-const executeWindowFunction = (browserWindowId, key) => {
+const executeWindowFunction = (browserWindowId, key, modifier = 'ctrl=twice') => {
   const browserWindow = getBrowserWindow(browserWindowId);
   if (!browserWindow) {
     return;
   }
   if (key === 'enableBrowserFullWidthGesture' || key === 'disableBrowserFullWidthGesture') {
-    setEnabled(browserWindowId, key === 'enableBrowserFullWidthGesture');
+    setEnabled(browserWindowId, key === 'enableBrowserFullWidthGesture', modifier);
     return;
   }
   if (key === 'toggleDevtools') {
@@ -8004,6 +8096,8 @@ const trash = async path => {
 const commandMap = {
   'AppWindow.createAppWindow': createAppWindow,
   'Beep.beep': beep$1,
+  'BrowserFind.find': wrapBrowserViewCommand(find),
+  'BrowserFind.stop': wrapBrowserViewCommand(stop$1),
   'Crash.crashMainProcess': crashMainProcess$1,
   'CreateMessagePort.createMessagePort': createMessagePort,
   'CreatePidMap.createPidMap': createPidMap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.41.2",
+  "version": "6.43.0",
   "keywords": [
     "lvce-editor",
     "electron"
@@ -17,6 +17,6 @@
     "electron": "44.0.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22.11.0"
   }
 }