@lvce-editor/main-process 6.8.0 → 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';
@@ -2794,6 +2794,78 @@ const create$4 = async ({
 
 const commandMapRef = Object.create(null);
 
+const Dash = '-';
+const Space$2 = ' ';
+
+const firstLetterLowerCase = string => {
+  return string[0].toLowerCase() + string.slice(1);
+};
+const camelCase = string => {
+  const parts = string.split(Space$2);
+  const lowerParts = parts.map(firstLetterLowerCase);
+  return lowerParts.join(Dash);
+};
+
+const formatUtilityProcessName = name => {
+  return camelCase(name);
+};
+
+const state$5 = {
+  all: Object.create(null)
+};
+const add$1 = (pid, process, name) => {
+  number(pid);
+  object(process);
+  string(name);
+  state$5.all[pid] = {
+    name,
+    process
+  };
+};
+const remove$1 = pid => {
+  number(pid);
+  delete state$5.all[pid];
+};
+const getAll = () => {
+  return Object.entries(state$5.all);
+};
+const getByName = name => {
+  for (const value of Object.values(state$5.all)) {
+    // @ts-ignore
+    if (value.name === name) {
+      // @ts-ignore
+      return value.process;
+    }
+  }
+  return undefined;
+};
+
+const trackUtilityProcess = (rawIpc, name) => {
+  if (!rawIpc?.pid) {
+    return;
+  }
+  const {
+    pid
+  } = rawIpc;
+  const formattedName = formatUtilityProcessName(name);
+  add$1(pid, rawIpc, formattedName);
+  const cleanup = () => {
+    remove$1(pid);
+    rawIpc.off('exit', handleExit);
+  };
+  const handleExit = () => {
+    cleanup();
+  };
+  rawIpc.on('exit', handleExit);
+};
+
+const createElectronUtilityProcessRpc = async options => {
+  const rpc = await create$5(options);
+  const rpcWithRawIpc = rpc;
+  trackUtilityProcess(rpcWithRawIpc.ipc?._rawIpc, options.name);
+  return rpc;
+};
+
 const getPortTuple = () => {
   const {
     port1,
@@ -2904,7 +2976,7 @@ const launchSharedProcess = async ({
     ...process.env,
     ...env
   };
-  const sharedProcessRpc = await create$5({
+  const sharedProcessRpc = await createElectronUtilityProcessRpc({
     argv: [],
     commandMap: commandMapRef,
     env: fullEnv,
@@ -2942,7 +3014,7 @@ const launchSharedProcess = async ({
   return sharedProcessRpc;
 };
 
-const state$5 = {
+const state$4 = {
   /**
    * @type {any}
    */
@@ -2953,14 +3025,14 @@ const getOrCreate = async ({
   env = {},
   method
 }) => {
-  if (!state$5.promise) {
+  if (!state$4.promise) {
     // @ts-ignore
-    state$5.promise = launchSharedProcess({
+    state$4.promise = launchSharedProcess({
       env,
       method
     });
   }
-  return state$5.promise;
+  return state$4.promise;
 };
 const send$1 = async (method, ...params) => {
   const rpc = await getOrCreate({
@@ -3123,14 +3195,14 @@ const createTitleBar = items => {
 
 const PHASE_DEFAULT = 0;
 const PHASE_SHUTDOWN = -1;
-const state$4 = {
+const state$3 = {
   phase: PHASE_DEFAULT
 };
 const isShutDown = () => {
-  return state$4.phase === PHASE_SHUTDOWN;
+  return state$3.phase === PHASE_SHUTDOWN;
 };
 const setShutDown = () => {
-  state$4.phase = PHASE_SHUTDOWN;
+  state$3.phase = PHASE_SHUTDOWN;
 };
 
 // TODO move this function to shared process
@@ -3427,21 +3499,21 @@ const openExternal = async url => {
   await shell.openExternal(url);
 };
 
-const state$3 = {
+const state$2 = {
   canceled: Object.create(null),
   fallThroughKeyBindings: [],
   views: Object.create(null)
 };
-const add$1 = (id, browserWindow, view) => {
+const add = (id, browserWindow, view) => {
   // state
-  state$3.views[id] = {
+  state$2.views[id] = {
     browserWindow,
     view
   };
 };
 const hasWebContents = id => {
   number(id);
-  return id in state$3.views;
+  return id in state$2.views;
 };
 /**
  *
@@ -3449,19 +3521,19 @@ const hasWebContents = id => {
  * @returns {{browserWindow: Electron.BrowserWindow, view: Electron.WebContentsView}}
  */
 const get$3 = id => {
-  return state$3.views[id];
+  return state$2.views[id];
 };
-const remove$1 = id => {
-  delete state$3.views[id];
+const remove = id => {
+  delete state$2.views[id];
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  state$3.fallThroughKeyBindings = fallthroughKeyBindings;
+  state$2.fallThroughKeyBindings = fallthroughKeyBindings;
 };
 const getFallthroughKeyBindings = () => {
-  return state$3.fallThroughKeyBindings;
+  return state$2.fallThroughKeyBindings;
 };
 const setCanceled = id => {
-  state$3.canceled[id] = true;
+  state$2.canceled[id] = true;
 };
 
 const shouldAllowNavigation = webContentsId => {
@@ -3775,20 +3847,20 @@ const createElectronSession = () => {
   return session;
 };
 
-const state$2 = {
+const state$1 = {
   session: undefined
 };
 const has = () => {
-  return Boolean(state$2.session);
+  return Boolean(state$1.session);
 };
 const get$2 = () => {
-  if (!state$2.session) {
+  if (!state$1.session) {
     throw new Error('session is not defined');
   }
-  return state$2.session;
+  return state$1.session;
 };
 const set$1 = value => {
-  state$2.session = value;
+  state$1.session = value;
 };
 
 const create$3 = rpc => {
@@ -4009,36 +4081,6 @@ const createMessagePort = async (ipcId, port, webContentsId) => {
   return webContentsId;
 };
 
-const state$1 = {
-  all: Object.create(null)
-};
-const add = (pid, process, name) => {
-  number(pid);
-  object(process);
-  string(name);
-  state$1.all[pid] = {
-    name,
-    process
-  };
-};
-const remove = pid => {
-  number(pid);
-  delete state$1.all[pid];
-};
-const getAll = () => {
-  return Object.entries(state$1.all);
-};
-const getByName = name => {
-  for (const value of Object.values(state$1.all)) {
-    // @ts-ignore
-    if (value.name === name) {
-      // @ts-ignore
-      return value.process;
-    }
-  }
-  return undefined;
-};
-
 const createPidMap = () => {
   const browserWindows = BrowserWindow.getAllWindows();
   const utilityProcesses = getAll();
@@ -4080,7 +4122,7 @@ const get = id => {
 };
 
 const createUtilityProcessRpc = async options => {
-  const rpc = await create$5({
+  const rpc = await createElectronUtilityProcessRpc({
     commandMap: commandMapRef,
     ...options
   });
@@ -4226,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 {
@@ -4590,7 +4726,7 @@ const KeyDown = 'keyDown';
 
 const Backspace$1 = 'Backspace';
 const Tab$1 = 'Tab';
-const Space$2 = ' ';
+const Space$1 = ' ';
 const Enter$1 = 'Enter';
 const Escape$1 = 'Escape';
 const PageUp$1 = 'PageUp';
@@ -4682,7 +4818,7 @@ const Backspace = 1;
 const Tab = 2;
 const Enter = 3;
 const Escape = 8;
-const Space$1 = 9;
+const Space = 9;
 const PageUp = 10;
 const PageDown = 11;
 const End = 255;
@@ -4852,7 +4988,7 @@ const keyCodeMap = {
   [RightArrow$1]: RightArrow,
   [SemiColon$1]: SemiColon,
   [Slash$1]: Slash,
-  [Space$2]: Space$1,
+  [Space$1]: Space,
   [Star$1]: Star,
   [Tab$1]: Tab,
   [UpArrow$1]: UpArrow
@@ -5260,7 +5396,7 @@ const createWebContentsView = async () => {
   const {
     id
   } = webContents;
-  add$1(id, browserWindow, view);
+  add(id, browserWindow, view);
   return id;
 };
 const attachEventListeners = webContentsId => {
@@ -5298,7 +5434,7 @@ const disposeWebContentsView = browserViewId => {
     browserWindow,
     view
   } = instance;
-  remove$1(browserViewId);
+  remove(browserViewId);
   browserWindow.contentView.removeChildView(view);
 };
 
@@ -5386,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
@@ -6718,22 +6858,6 @@ const create$1 = async ({
   return ipc;
 };
 
-const Dash = '-';
-const Space = ' ';
-
-const firstLetterLowerCase = string => {
-  return string[0].toLowerCase() + string.slice(1);
-};
-const camelCase = string => {
-  const parts = string.split(Space);
-  const lowerParts = parts.map(firstLetterLowerCase);
-  return lowerParts.join(Dash);
-};
-
-const formatUtilityProcessName = name => {
-  return camelCase(name);
-};
-
 const {
   create
 } = IpcParentWithElectronUtilityProcess$1$1;
@@ -6744,22 +6868,7 @@ const effects = ({
   name,
   rawIpc
 }) => {
-  if (!rawIpc.pid) {
-    return;
-  }
-  const {
-    pid
-  } = rawIpc;
-  const formattedName = formatUtilityProcessName(name);
-  add(pid, rawIpc, formattedName);
-  const cleanup = () => {
-    remove(pid);
-    rawIpc.off('exit', handleExit);
-  };
-  const handleExit = () => {
-    cleanup();
-  };
-  rawIpc.on('exit', handleExit);
+  trackUtilityProcess(rawIpc, name);
 };
 
 const IpcParentWithElectronUtilityProcess = {
@@ -6846,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,
@@ -6874,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.0",
+  "version": "6.8.2",
   "keywords": [
     "lvce-editor",
     "electron"