@lvce-editor/main-process 6.8.1 → 6.8.2

package/dist/mainProcessMain.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
 import { spawn } from 'node:child_process';
 import { Console } from 'node:console';
-import { createWriteStream, readFileSync, openAsBlob, existsSync } from 'node:fs';
+import { createWriteStream, readFileSync, openAsBlob, existsSync, mkdirSync, openSync, writeSync, closeSync, rmSync } from 'node:fs';
 import { tmpdir, homedir } from 'node:os';
 import * as NodePath from 'node:path';
 import { dirname, join as join$1 } from 'node:path';
@@ -4268,6 +4268,100 @@ const openContextMenu = async (menuItems, x, y) => {
   }
 };
 
+const getFileName = workerName => {
+  const safeWorkerName = workerName.replaceAll(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-/, '').replace(/-$/, '') || 'worker';
+  return `${safeWorkerName}-${Date.now()}.heapsnapshot`;
+};
+const takeWorkerHeapSnapshot = async (windowId, workerName) => {
+  number(windowId);
+  string(workerName);
+  const browserWindow = Electron.BrowserWindow.fromId(windowId);
+  if (!browserWindow) {
+    throw new Error(`Browser window not found: ${windowId}`);
+  }
+  const electronDebugger = browserWindow.webContents.debugger;
+  const wasAttached = electronDebugger.isAttached();
+  let fileDescriptor;
+  let filePath = '';
+  let sessionId = '';
+  let success = false;
+  if (!wasAttached) {
+    electronDebugger.attach();
+  }
+  try {
+    const {
+      frameTree
+    } = await electronDebugger.sendCommand('Page.getFrameTree');
+    const {
+      targetInfos
+    } = await electronDebugger.sendCommand('Target.getTargets');
+    const target = targetInfos.find(targetInfo => targetInfo.type === 'worker' && targetInfo.title === workerName && targetInfo.parentFrameId === frameTree.frame.id);
+    if (!target) {
+      throw new Error(`Worker not found: ${workerName}`);
+    }
+    const attachResult = await electronDebugger.sendCommand('Target.attachToTarget', {
+      flatten: true,
+      targetId: target.targetId
+    });
+    sessionId = attachResult.sessionId;
+    const downloadsPath = Electron.app.getPath('downloads');
+    mkdirSync(downloadsPath, {
+      recursive: true
+    });
+    filePath = join$1(downloadsPath, getFileName(workerName));
+    fileDescriptor = openSync(filePath, 'wx');
+    const currentFileDescriptor = fileDescriptor;
+    let writeError;
+    const handleMessage = (_event, method, parameters, messageSessionId) => {
+      if (method !== 'HeapProfiler.addHeapSnapshotChunk' || messageSessionId !== sessionId || writeError) {
+        return;
+      }
+      try {
+        writeSync(currentFileDescriptor, parameters.chunk);
+      } catch (error) {
+        writeError = error;
+      }
+    };
+    electronDebugger.on('message', handleMessage);
+    try {
+      await electronDebugger.sendCommand('HeapProfiler.enable', undefined, sessionId);
+      await electronDebugger.sendCommand('HeapProfiler.takeHeapSnapshot', {
+        reportProgress: false
+      }, sessionId);
+      if (writeError) {
+        throw writeError;
+      }
+    } finally {
+      electronDebugger.off('message', handleMessage);
+    }
+    success = true;
+    return filePath;
+  } finally {
+    try {
+      if (fileDescriptor !== undefined) {
+        closeSync(fileDescriptor);
+      }
+      if (!success && filePath) {
+        rmSync(filePath, {
+          force: true
+        });
+      }
+    } finally {
+      try {
+        if (sessionId && electronDebugger.isAttached()) {
+          await electronDebugger.sendCommand('Target.detachFromTarget', {
+            sessionId
+          });
+        }
+      } finally {
+        if (!wasAttached && electronDebugger.isAttached()) {
+          electronDebugger.detach();
+        }
+      }
+    }
+  }
+};
+
 const getPerformanceEntries = () => {
   const entries = getEntries();
   const {
@@ -5428,6 +5522,10 @@ const getDomTree = async view => {
   const result = await getBodyOuterHtml(view);
   return getSlimCode(result);
 };
+const capturePage = async view => {
+  const image = await view.webContents.capturePage();
+  return image.toDataURL();
+};
 const insertCss = async (view, code) => {
   const {
     webContents
@@ -6857,6 +6955,7 @@ const commandMap = {
   'ElectronContextMenu.openContextMenu': openContextMenu,
   'ElectronDeveloper.crashMainProcess': crashMainProcess,
   'ElectronDeveloper.getPerformanceEntries': getPerformanceEntries,
+  'ElectronDeveloper.takeWorkerHeapSnapshot': takeWorkerHeapSnapshot,
   'ElectronDialog.showMessageBox': showMessageBox,
   'ElectronDialog.showOpenDialog': showOpenDialog,
   'ElectronDialog.showSaveDialog': showSaveDialog,
@@ -6885,6 +6984,7 @@ const commandMap = {
   'ElectronWebContentsViewFunctions.addToWindow': addToWindow,
   'ElectronWebContentsViewFunctions.backward': wrapBrowserViewCommand(backward),
   'ElectronWebContentsViewFunctions.cancelNavigation': wrapBrowserViewCommand(cancelNavigation),
+  'ElectronWebContentsViewFunctions.capturePage': wrapBrowserViewCommand(capturePage),
   'ElectronWebContentsViewFunctions.copyImageAt': wrapBrowserViewCommand(copyImageAt),
   'ElectronWebContentsViewFunctions.executeJavaScript': wrapBrowserViewCommand(executeJavaScript),
   'ElectronWebContentsViewFunctions.focus': wrapBrowserViewCommand(focus),

package/package.json

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