@lvce-editor/process-explorer-worker 3.3.0 → 3.4.0

package/index.js

@@ -119,7 +119,7 @@ const terminate = () => {
   globalThis.close();
 };
 
-const None$1 = 0;
+const None$2 = 0;
 const Collapsed = 1;
 const Expanded = 2;
 
@@ -144,7 +144,7 @@ const getChildren = (processes, collapsedPids, process, depth) => {
 };
 const withChildren = (processes, collapsedPids, process, depth) => {
   const processHasChildren = hasChildren(processes, process.pid);
-  let flags = None$1;
+  let flags = None$2;
   if (processHasChildren && collapsedPids.includes(process.pid)) {
     flags = Collapsed;
   } else if (processHasChildren) {
@@ -181,11 +181,14 @@ const collapseAll = state => {
 };
 
 const {
+  dispose: dispose$3,
   get: get$2,
   getCommandIds,
+  getKeys,
   registerCommands,
   set: set$9,
   wrapCommand,
+  wrapGetter,
   wrapLoadContent
 } = create$e();
 
@@ -215,264 +218,6 @@ const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0,
   return state;
 };
 
-const isEqual$1 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
-};
-
-const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.visibleProcesses === newState.visibleProcesses;
-};
-
-const RenderItems = 1;
-const RenderFocus = 2;
-const RenderFocusContext = 3;
-
-const modules = [isEqual, isEqual$1, isEqual$1];
-const numbers = [RenderItems, RenderFocus, RenderFocusContext];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    oldState,
-    scheduledState
-  } = get$2(uid);
-  return diff(oldState, scheduledState);
-};
-
-const expandAll = state => {
-  const collapsedPids = [];
-  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
-  return {
-    ...state,
-    collapsedPids,
-    visibleProcesses
-  };
-};
-
-const focusIndex = (state, index) => {
-  if (index < -1 || index >= state.visibleProcesses.length) {
-    return state;
-  }
-  return {
-    ...state,
-    focusedIndex: index
-  };
-};
-
-const focusFirst = state => {
-  if (state.visibleProcesses.length === 0) {
-    return state;
-  }
-  return focusIndex(state, 0);
-};
-
-const focusLast = state => {
-  if (state.visibleProcesses.length === 0) {
-    return state;
-  }
-  return focusIndex(state, state.visibleProcesses.length - 1);
-};
-
-const focusNext = state => {
-  if (state.focusedIndex >= state.visibleProcesses.length - 1) {
-    return state;
-  }
-  return focusIndex(state, state.focusedIndex + 1);
-};
-
-const focusPrevious = state => {
-  if (state.focusedIndex === -1 && state.visibleProcesses.length > 0) {
-    return focusIndex(state, state.visibleProcesses.length - 1);
-  }
-  if (state.focusedIndex <= 0) {
-    return state;
-  }
-  return focusIndex(state, state.focusedIndex - 1);
-};
-
-const Div = 4;
-const Table$1 = 9;
-const TBody = 10;
-const Td = 11;
-const Text = 12;
-const Th = 13;
-const THead = 14;
-const Tr = 15;
-const Pre = 51;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const TargetName = 'event.target.name';
-
-const Enter = 3;
-const Space = 9;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const ContextMenu = 56;
-const Star = 131;
-
-const Script = 2;
-
-const CtrlCmd = 1 << 11 >>> 0;
-
-const Electron = 2;
-const Remote = 3;
-
-const DebugWorker = 55;
-const EditorWorker = 99;
-const ErrorWorker = 3308;
-const FileSystemWorker$1 = 209;
-const IconThemeWorker = 7009;
-const OpenerWorker = 4561;
-const RendererWorker$1 = 1;
-const TestWorker = 9001;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetDom2 = 'Viewlet.setDom2';
-const SetFocusContext = 'Viewlet.setFocusContext';
-
-const Empty = 0;
-const FocusExplorer = 13;
-
-const getKeyBindings$1 = () => {
-  return [{
-    command: 'ProcessExplorer.handleArrowRight',
-    key: RightArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleArrowLeft',
-    key: LeftArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusFirst',
-    key: Home,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusLast',
-    key: End,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusPrevious',
-    key: UpArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusNext',
-    key: DownArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.collapseAll',
-    key: CtrlCmd | LeftArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.expandAll',
-    key: CtrlCmd | RightArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.expandAll',
-    key: CtrlCmd | Star,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleDoubleClick',
-    key: Enter,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleDoubleClick',
-    key: Space,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleContextMenu',
-    key: ContextMenu,
-    when: FocusExplorer
-  }];
-};
-
-const toggleIndex = (state, index) => {
-  const process = state.visibleProcesses[index];
-  if (!process || process.flags === None$1) {
-    return state;
-  }
-  const collapsedPids = state.collapsedPids.includes(process.pid) ? state.collapsedPids.filter(pid => pid !== process.pid) : [...state.collapsedPids, process.pid];
-  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
-  return {
-    ...state,
-    collapsedPids,
-    focusedIndex: Math.min(index, visibleProcesses.length - 1),
-    visibleProcesses
-  };
-};
-
-const getParentIndex = state => {
-  const process = state.visibleProcesses[state.focusedIndex];
-  if (!process) {
-    return -1;
-  }
-  for (let i = state.focusedIndex - 1; i >= 0; i--) {
-    const otherProcess = state.visibleProcesses[i];
-    if (otherProcess.depth === process.depth - 1) {
-      return i;
-    }
-  }
-  return -1;
-};
-const handleArrowLeft = state => {
-  const process = state.visibleProcesses[state.focusedIndex];
-  if (!process) {
-    return state;
-  }
-  if (process.flags === Expanded) {
-    return toggleIndex(state, state.focusedIndex);
-  }
-  const parentIndex = getParentIndex(state);
-  if (parentIndex === -1) {
-    return state;
-  }
-  return focusIndex(state, parentIndex);
-};
-
-const handleArrowRight = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process) {
-    return state;
-  }
-  if (process.flags === Collapsed) {
-    return toggleIndex(state, focusedIndex);
-  }
-  const nextProcess = visibleProcesses[focusedIndex + 1];
-  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
-    return focusIndex(state, focusedIndex + 1);
-  }
-  return state;
-};
-
-const handleBlur = state => {
-  return {
-    ...state,
-    focused: false
-  };
-};
-
-const handleClickAt = (state, index) => {
-  return focusIndex(state, index);
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1717,6 +1462,56 @@ const create = rpcId => {
   };
 };
 
+const Div = 4;
+const Table$1 = 9;
+const TBody = 10;
+const Td = 11;
+const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const Pre = 51;
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const TargetName = 'event.target.name';
+
+const Enter = 3;
+const Space = 9;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+const ContextMenu = 56;
+const Star = 131;
+
+const Script = 2;
+
+const CtrlCmd = 1 << 11 >>> 0;
+
+const None$1 = 0;
+
+const Electron = 2;
+const Remote = 3;
+
+const DebugWorker = 55;
+const EditorWorker = 99;
+const ErrorWorker = 3308;
+const FileSystemWorker$1 = 209;
+const IconThemeWorker = 7009;
+const OpenerWorker = 4561;
+const RendererWorker$1 = 1;
+const TestWorker = 9001;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+
+const Empty = 0;
+const FocusExplorer = 13;
+
 const {
   set: set$7
 } = create(EditorWorker);
@@ -1747,7 +1542,7 @@ const {
 } = create(IconThemeWorker);
 
 const {
-  dispose,
+  dispose: dispose$2,
   invoke: invoke$1,
   invokeAndTransfer,
   registerMockRpc,
@@ -1974,7 +1769,7 @@ const confirm = async (message, options) => {
 const getRecentlyOpened = async () => {
   return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
-const getKeyBindings = async () => {
+const getKeyBindings$1 = async () => {
   return invoke$1('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
@@ -2195,7 +1990,7 @@ const RendererWorker = {
   confirm,
   createViewlet,
   disableExtension,
-  dispose,
+  dispose: dispose$2,
   disposeEditor,
   enableExtension,
   getActiveEditorId,
@@ -2214,7 +2009,7 @@ const RendererWorker = {
   getFolderIcon,
   getFolderSize,
   getIcons,
-  getKeyBindings,
+  getKeyBindings: getKeyBindings$1,
   getLogsDir,
   getMarkdownDom,
   getNodeVersion,
@@ -2319,52 +2114,328 @@ const RendererWorker = {
   writeFile
 };
 
+const debugProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  await invoke$1('AttachDebugger.attachDebugger', process.pid);
+  return state;
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.visibleProcesses === newState.visibleProcesses;
+};
+
+const RenderItems = 1;
+const RenderFocus = 2;
+const RenderFocusContext = 3;
+
+const modules = [isEqual, isEqual$1, isEqual$1];
+const numbers = [RenderItems, RenderFocus, RenderFocusContext];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    oldState,
+    scheduledState
+  } = get$2(uid);
+  return diff(oldState, scheduledState);
+};
+
+const processExplorerUpdateInterval = 1000;
+
+const intervals = new Map();
+const pending = new Set();
+const dispose$1 = uid => {
+  const interval = intervals.get(uid);
+  if (interval) {
+    clearInterval(interval);
+    intervals.delete(uid);
+  }
+  pending.delete(uid);
+};
+const update = async uid => {
+  if (!getKeys().includes(uid)) {
+    dispose$1(uid);
+    return;
+  }
+  if (pending.has(uid)) {
+    return;
+  }
+  pending.add(uid);
+  try {
+    await invoke$1('ProcessExplorer.update');
+  } catch (error) {
+    console.error(error);
+  } finally {
+    pending.delete(uid);
+  }
+};
+const start = (uid, interval = processExplorerUpdateInterval) => {
+  if (interval === 0 || intervals.has(uid)) {
+    return;
+  }
+  const intervalId = setInterval(() => {
+    void update(uid);
+  }, interval);
+  intervals.set(uid, intervalId);
+};
+
+const dispose = uid => {
+  dispose$1(uid);
+  dispose$3(uid);
+};
+
+const expandAll = state => {
+  const collapsedPids = [];
+  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
+  return {
+    ...state,
+    collapsedPids,
+    visibleProcesses
+  };
+};
+
+const focusIndex = (state, index) => {
+  if (index < -1 || index >= state.visibleProcesses.length) {
+    return state;
+  }
+  return {
+    ...state,
+    focusedIndex: index
+  };
+};
+
+const focusFirst = state => {
+  if (state.visibleProcesses.length === 0) {
+    return state;
+  }
+  return focusIndex(state, 0);
+};
+
+const focusLast = state => {
+  if (state.visibleProcesses.length === 0) {
+    return state;
+  }
+  return focusIndex(state, state.visibleProcesses.length - 1);
+};
+
+const focusNext = state => {
+  if (state.focusedIndex >= state.visibleProcesses.length - 1) {
+    return state;
+  }
+  return focusIndex(state, state.focusedIndex + 1);
+};
+
+const focusPrevious = state => {
+  if (state.focusedIndex === -1 && state.visibleProcesses.length > 0) {
+    return focusIndex(state, state.visibleProcesses.length - 1);
+  }
+  if (state.focusedIndex <= 0) {
+    return state;
+  }
+  return focusIndex(state, state.focusedIndex - 1);
+};
+
+const getKeyBindings = () => {
+  return [{
+    command: 'ProcessExplorer.handleArrowRight',
+    key: RightArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleArrowLeft',
+    key: LeftArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusFirst',
+    key: Home,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusLast',
+    key: End,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusPrevious',
+    key: UpArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusNext',
+    key: DownArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.collapseAll',
+    key: CtrlCmd | LeftArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.expandAll',
+    key: CtrlCmd | RightArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.expandAll',
+    key: CtrlCmd | Star,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleDoubleClick',
+    key: Enter,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleDoubleClick',
+    key: Space,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleContextMenu',
+    key: ContextMenu,
+    when: FocusExplorer
+  }];
+};
+
 const isDebuggable = command => {
   return command.includes('node ') || command.includes('node.exe') || command.includes('node.mojom.NodeService');
 };
 
 const KillProcess = 'Kill Process';
 const DebugProcess = 'Debug Process';
-const getMenuItems = process => {
-  const menuItems = [{
+
+const getMenuEntries = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
+  if (!process) {
+    return [];
+  }
+  const menuEntries = [{
+    args: [state.focusedIndex],
+    command: 'ProcessExplorer.killProcess',
+    flags: None$1,
+    id: 'killProcess',
     label: KillProcess
   }];
   if (isDebuggable(process.cmd)) {
-    menuItems.push({
+    menuEntries.push({
+      args: [state.focusedIndex],
+      command: 'ProcessExplorer.debugProcess',
+      flags: None$1,
+      id: 'debugProcess',
       label: DebugProcess
     });
   }
-  return menuItems;
+  return menuEntries;
 };
 
-const SigTerm = 'SIGTERM';
+const ProcessExplorer$1 = 29;
 
-const handleContextMenuSelect = async (label, process) => {
-  switch (label) {
-    case DebugProcess:
-      await invoke$1('AttachDebugger.attachDebugger', process.pid);
-      return;
-    case KillProcess:
-      await invoke$1('Process.kill', process.pid, SigTerm);
-      return;
-    default:
-      return;
-  }
+const getMenuEntryIds = () => {
+  return [ProcessExplorer$1];
 };
-const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0) => {
+
+const toggleIndex = (state, index) => {
   const process = state.visibleProcesses[index];
+  if (!process || process.flags === None$2) {
+    return state;
+  }
+  const collapsedPids = state.collapsedPids.includes(process.pid) ? state.collapsedPids.filter(pid => pid !== process.pid) : [...state.collapsedPids, process.pid];
+  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
+  return {
+    ...state,
+    collapsedPids,
+    focusedIndex: Math.min(index, visibleProcesses.length - 1),
+    visibleProcesses
+  };
+};
+
+const getParentIndex = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
+  if (!process) {
+    return -1;
+  }
+  for (let i = state.focusedIndex - 1; i >= 0; i--) {
+    const otherProcess = state.visibleProcesses[i];
+    if (otherProcess.depth === process.depth - 1) {
+      return i;
+    }
+  }
+  return -1;
+};
+const handleArrowLeft = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
   if (!process) {
     return state;
   }
-  const menuItems = getMenuItems(process);
-  const event = await invoke$1('ElectronContextMenu.openContextMenu', menuItems, x, y, process);
-  if (event.type === 'close' || !event.data) {
+  if (process.flags === Expanded) {
+    return toggleIndex(state, state.focusedIndex);
+  }
+  const parentIndex = getParentIndex(state);
+  if (parentIndex === -1) {
+    return state;
+  }
+  return focusIndex(state, parentIndex);
+};
+
+const handleArrowRight = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process) {
     return state;
   }
-  await handleContextMenuSelect(event.data, process);
+  if (process.flags === Collapsed) {
+    return toggleIndex(state, focusedIndex);
+  }
+  const nextProcess = visibleProcesses[focusedIndex + 1];
+  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
+    return focusIndex(state, focusedIndex + 1);
+  }
   return state;
 };
 
+const handleBlur = state => {
+  return {
+    ...state,
+    focused: false
+  };
+};
+
+const handleClickAt = (state, index) => {
+  return focusIndex(state, index);
+};
+
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
+};
+
+const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  const newState = {
+    ...state,
+    focused: false,
+    focusedIndex: index
+  };
+  set$9(state.uid, state, newState);
+  await show2(state.uid, ProcessExplorer$1, x, y, {
+    index,
+    menuId: ProcessExplorer$1
+  });
+  return newState;
+};
+
 const handleDoubleClick = (state, index = state.focusedIndex) => {
   return toggleIndex(state, index);
 };
@@ -2376,6 +2447,17 @@ const handleFocus = state => {
   };
 };
 
+const SigTerm = 'SIGTERM';
+
+const killProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  await invoke$1('Process.kill', process.pid, SigTerm);
+  return state;
+};
+
 const sendMessagePortToProcessExplorer = async port => {
   const rendererWorker = RendererWorker;
   await rendererWorker.sendMessagePortToProcessExplorer(port);
@@ -2468,7 +2550,9 @@ const refresh = async state => {
   try {
     await initializeProcessExplorer(state.platform);
     const includeElectronData = state.platform === Electron;
-    const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId', includeElectronData));
+    const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId', {
+      includeElectronData
+    }));
     const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, includeElectronData);
     const visibleProcesses = getVisibleProcesses(processes, state.collapsedPids, rootPid);
     return {
@@ -2496,6 +2580,7 @@ const refresh = async state => {
 
 const loadContent = async state => {
   const newState = await refresh(state);
+  start(state.uid);
   return {
     error: undefined,
     state: newState
@@ -2579,7 +2664,7 @@ const getPaddingLeft = process => {
     return '0';
   }
   const depthCh = (process.depth - 1) * 1.5;
-  if (process.flags === None$1) {
+  if (process.flags === None$2) {
     return `calc(${depthCh}ch + 17px)`;
   }
   return `${depthCh}ch`;
@@ -2774,14 +2859,18 @@ const renderEventListeners = () => {
 const commandMap = {
   'ProcessExplorer.collapseAll': wrapCommand(collapseAll),
   'ProcessExplorer.create': create$d,
+  'ProcessExplorer.debugProcess': wrapCommand(debugProcess),
   'ProcessExplorer.diff2': diff2,
+  'ProcessExplorer.dispose': dispose,
   'ProcessExplorer.expandAll': wrapCommand(expandAll),
   'ProcessExplorer.focusFirst': wrapCommand(focusFirst),
   'ProcessExplorer.focusLast': wrapCommand(focusLast),
   'ProcessExplorer.focusNext': wrapCommand(focusNext),
   'ProcessExplorer.focusPrevious': wrapCommand(focusPrevious),
   'ProcessExplorer.getCommandIds': getCommandIds,
-  'ProcessExplorer.getKeyBindings': getKeyBindings$1,
+  'ProcessExplorer.getKeyBindings': getKeyBindings,
+  'ProcessExplorer.getMenuEntries': wrapGetter(getMenuEntries),
+  'ProcessExplorer.getMenuEntryIds': getMenuEntryIds,
   'ProcessExplorer.handleArrowLeft': wrapCommand(handleArrowLeft),
   'ProcessExplorer.handleArrowRight': wrapCommand(handleArrowRight),
   'ProcessExplorer.handleBlur': wrapCommand(handleBlur),
@@ -2789,11 +2878,13 @@ const commandMap = {
   'ProcessExplorer.handleContextMenu': wrapCommand(handleContextMenu),
   'ProcessExplorer.handleDoubleClick': wrapCommand(handleDoubleClick),
   'ProcessExplorer.handleFocus': wrapCommand(handleFocus),
+  'ProcessExplorer.killProcess': wrapCommand(killProcess),
   'ProcessExplorer.loadContent': wrapLoadContent(loadContent),
   'ProcessExplorer.refresh': wrapCommand(refresh),
   'ProcessExplorer.render2': render2,
   'ProcessExplorer.renderEventListeners': renderEventListeners,
-  'ProcessExplorer.terminate': terminate
+  'ProcessExplorer.terminate': terminate,
+  'ProcessExplorer.update': wrapCommand(refresh)
 };
 
 const sendMessagePortToErrorWorker = async port => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer-worker",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",