@lvce-editor/process-explorer-worker 3.16.0 → 3.18.0

package/index.js

@@ -240,7 +240,7 @@ const {
   getCommandIds,
   getKeys: getKeys$1,
   registerCommands,
-  set: set$7,
+  set: set$9,
   wrapCommand,
   wrapGetter,
   wrapLoadContent
@@ -289,7 +289,7 @@ const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0,
     x,
     y
   };
-  set$7(state.uid, state, state);
+  set$9(state.uid, state, state);
   return state;
 };
 
@@ -1268,7 +1268,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$6 = (id, rpc) => {
+const set$8 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1301,7 +1301,7 @@ const create$a = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$6(rpcId, mockRpc);
+      set$8(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1310,7 +1310,7 @@ const create$a = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$6(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
@@ -1509,6 +1509,7 @@ const ErrorWorker = 3308;
 const FileSystemWorker$1 = 209;
 const MainProcess = -5;
 const ProcessExplorerRenderer = 33;
+const RendererProcess = 1670;
 const RendererWorker = 1;
 
 const FocusSelector = 'Viewlet.focusSelector';
@@ -1520,39 +1521,44 @@ const Empty = 0;
 const FocusExplorer = 13;
 
 const {
-  invoke: invoke$3,
-  set: set$5
+  invoke: invoke$5,
+  set: set$7
 } = create$a(ErrorWorker);
 const prepare = async error => {
-  return invoke$3('Errors.prepare', error);
+  return invoke$5('Errors.prepare', error);
 };
 
 const {
-  set: set$4
+  set: set$6
 } = create$a(FileSystemWorker$1);
 
 const FileSystemWorker = {
   __proto__: null,
-  set: set$4
+  set: set$6
 };
 
 const {
   dispose: dispose$4,
-  invoke: invoke$2,
-  set: set$3
+  invoke: invoke$4,
+  set: set$5
 } = create$a(MainProcess);
 
 const {
-  invoke: invoke$1,
+  invoke: invoke$3,
+  set: set$4
+} = create$a(RendererProcess);
+
+const {
+  invoke: invoke$2,
   invokeAndTransfer,
-  set: set$2
+  set: set$3
 } = create$a(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
   number(x);
   number(y);
-  await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const sendMessagePortToErrorWorker$1 = async (port, rpcId) => {
   const command = 'Errors.handleMessagePort';
@@ -1572,7 +1578,7 @@ const debugProcess = async (state, index = state.focusedIndex) => {
   if (!process) {
     return state;
   }
-  await invoke$1('AttachDebugger.attachDebugger', process.pid);
+  await invoke$2('AttachDebugger.attachDebugger', process.pid);
   return state;
 };
 
@@ -1631,7 +1637,7 @@ const update = async uid => {
   }
   pending.add(uid);
   try {
-    await invoke$1('ProcessExplorer.update');
+    await invoke$2('ProcessExplorer.update');
   } catch (error) {
     console.error(error);
   } finally {
@@ -1675,11 +1681,11 @@ const handleProcessExplorerRpcClose = async () => {
       scheduledState
     } = viewletState;
     const newState = toProcessExplorerRpcClosedState(scheduledState);
-    set$7(uid, oldState, newState);
+    set$9(uid, oldState, newState);
     didUpdate = true;
   }
   if (didUpdate) {
-    await invoke$1('ProcessExplorer.rerender');
+    await invoke$2('ProcessExplorer.rerender');
   }
 };
 
@@ -2001,7 +2007,7 @@ const launchProcessExplorerNode = async onClose => {
       const {
         protocols,
         url
-      } = await invoke$1('WebSocketCapability.create', 'process-explorer');
+      } = await invoke$2('WebSocketCapability.create', 'process-explorer');
       const webSocket = new WebSocket(url, protocols);
       webSocket.addEventListener('close', onClose);
       return await create$3({
@@ -2024,39 +2030,39 @@ const launchProcessExplorerNode = async onClose => {
   }
 };
 
-const state$1 = {
+const state$2 = {
   rpc: undefined
 };
-const invoke = async (method, ...params) => {
-  if (!state$1.rpc) {
+const invoke$1 = async (method, ...params) => {
+  if (!state$2.rpc) {
     throw new Error('ProcessExplorerModule is not initialized');
   }
-  return state$1.rpc.invoke(method, ...params);
+  return state$2.rpc.invoke(method, ...params);
 };
-const set$1 = newRpc => {
-  state$1.rpc = newRpc;
+const set$2 = newRpc => {
+  state$2.rpc = newRpc;
 };
 const clear = () => {
-  state$1.rpc = undefined;
+  state$2.rpc = undefined;
 };
 const dispose$2 = async () => {
   const {
     rpc
-  } = state$1;
-  state$1.rpc = undefined;
+  } = state$2;
+  state$2.rpc = undefined;
   await rpc?.dispose();
 };
 
-const state = {
+const state$1 = {
   initializedPlatform: 0
 };
 const handleClose = async () => {
-  state.initializedPlatform = 0;
+  state$1.initializedPlatform = 0;
   clear();
   await handleProcessExplorerRpcClose();
 };
 const initializeProcessExplorer = async platform => {
-  if (state.initializedPlatform === platform) {
+  if (state$1.initializedPlatform === platform) {
     return;
   }
   if (platform === Electron) {
@@ -2064,24 +2070,24 @@ const initializeProcessExplorer = async platform => {
       mainProcessRpc,
       processExplorerRpc
     } = await launchProcessExplorerElectron();
-    set$3(mainProcessRpc);
-    set$1(processExplorerRpc);
-    state.initializedPlatform = platform;
+    set$5(mainProcessRpc);
+    set$2(processExplorerRpc);
+    state$1.initializedPlatform = platform;
     return;
   }
   if (platform === Remote) {
     const rpc = await launchProcessExplorerNode(() => {
       void handleClose();
     });
-    set$1(rpc);
-    state.initializedPlatform = platform;
+    set$2(rpc);
+    state$1.initializedPlatform = platform;
   }
 };
 const dispose$1 = async () => {
   const {
     initializedPlatform
-  } = state;
-  state.initializedPlatform = 0;
+  } = state$1;
+  state$1.initializedPlatform = 0;
   if (initializedPlatform === Electron) {
     await Promise.all([dispose$4(), dispose$2()]);
     return;
@@ -2098,14 +2104,14 @@ const dispose = async uid => {
 };
 
 const createE2eFixtureProcess = async (state, marker) => {
-  const pid = await invoke('Process.createE2eFixtureProcess', marker);
+  const pid = await invoke$1('Process.createE2eFixtureProcess', marker);
   return {
     ...state,
     rootPid: pid
   };
 };
 const disposeE2eFixtureProcess = async (_uid, pidOrMarker) => {
-  await invoke('Process.disposeE2eFixtureProcess', pidOrMarker);
+  await invoke$1('Process.disposeE2eFixtureProcess', pidOrMarker);
 };
 
 const expandAll = state => {
@@ -2336,7 +2342,7 @@ const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0
     focused: false,
     focusedIndex: numericIndex
   };
-  set$7(state.uid, state, newState);
+  set$9(state.uid, state, newState);
   await show2(state.uid, ProcessExplorer$1, x, y, {
     index: numericIndex,
     menuId: ProcessExplorer$1
@@ -2355,12 +2361,45 @@ const handleFocus = state => {
   };
 };
 
+const state = {
+  connected: false
+};
+const isConnected = () => {
+  const {
+    connected
+  } = state;
+  return connected;
+};
+const invoke = (method, ...params) => invoke$3(method, ...params);
+const set$1 = rpc => {
+  set$4(rpc);
+  state.connected = true;
+};
+
+const handleMessagePort = async (port, viewletCommandMap) => {
+  const executeViewletCommand = async (uid, command, ...args) => {
+    const fn = viewletCommandMap[`ProcessExplorer.${command}`];
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Viewlet command not found: ${command}`);
+    }
+    await fn(uid, ...args);
+    await invoke$2('Viewlet.requestRender', uid);
+  };
+  const rpc = await create$6({
+    commandMap: {
+      'Viewlet.executeViewletCommand': executeViewletCommand
+    },
+    messagePort: port
+  });
+  set$1(rpc);
+};
+
 const killProcess = async (state, index = state.focusedIndex) => {
   const process = state.visibleProcesses[index];
   if (!process) {
     return state;
   }
-  const killPromise = invoke('Process.kill', process.pid);
+  const killPromise = invoke$1('Process.kill', process.pid);
   if (process.name === 'process-explorer') {
     dispose$3(state.uid);
     void killPromise.catch(() => {});
@@ -2487,16 +2526,16 @@ const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
 };
 const listProcesses = async (rootPid, platform) => {
   if (platform === Electron) {
-    const pidMap = await invoke$2('CreatePidMap.createPidMap');
-    return invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false, pidMap);
+    const pidMap = await invoke$4('CreatePidMap.createPidMap');
+    return invoke$1('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false, pidMap);
   }
-  return invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false);
+  return invoke$1('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false);
 };
 const refresh = async state => {
   try {
     await initializeProcessExplorer(state.platform);
     const includeElectronData = state.platform === Electron;
-    const rootPid = state.rootPid === -1 ? await invoke('ProcessId.getMainProcessId', {
+    const rootPid = state.rootPid === -1 ? await invoke$1('ProcessId.getMainProcessId', {
       includeElectronData
     }) : state.rootPid;
     const processes = await listProcesses(rootPid, state.platform);
@@ -3070,8 +3109,16 @@ const render2 = (uid, diffResult) => {
     oldState,
     scheduledState
   } = get$2(uid);
-  set$7(uid, scheduledState, scheduledState);
-  return applyRender(oldState, scheduledState, diffResult);
+  set$9(uid, scheduledState, scheduledState);
+  const commands = applyRender(oldState, scheduledState, diffResult);
+  if (!isConnected()) return commands;
+  return renderDirect(uid, commands);
+};
+const renderDirect = async (uid, commands) => {
+  const rendererWorkerCommands = commands.filter(command => command[0] === 'Viewlet.setFocusContext');
+  const rendererProcessCommands = commands.filter(command => command[0] !== 'Viewlet.setFocusContext');
+  const transactionId = await invoke('Viewlet.queueCommands', uid, rendererProcessCommands);
+  return [...rendererWorkerCommands, ['Viewlet.commitPending', uid, transactionId]];
 };
 
 const renderEventListeners = () => {
@@ -3161,6 +3208,7 @@ const setUpdateInterval = (state, updateInterval) => {
   };
 };
 
+const handleDirectMessagePort = port => handleMessagePort(port, commandMap);
 const commandMap = {
   'ProcessExplorer.collapseAll': wrapCommand(collapseAll),
   'ProcessExplorer.create': create$d,
@@ -3185,6 +3233,7 @@ const commandMap = {
   'ProcessExplorer.handleContextMenu': wrapCommand(handleContextMenu),
   'ProcessExplorer.handleDoubleClick': wrapCommand(handleDoubleClick),
   'ProcessExplorer.handleFocus': wrapCommand(handleFocus),
+  'ProcessExplorer.handleMessagePort': handleDirectMessagePort,
   'ProcessExplorer.killProcess': wrapCommand(killProcess),
   'ProcessExplorer.loadContent': wrapLoadContent(loadContent),
   'ProcessExplorer.refresh': wrapCommand(refresh),
@@ -3216,7 +3265,7 @@ const createErrorWorkerRpc = async () => {
 
 const initializeErrorWorker = async () => {
   const rpc = await createErrorWorkerRpc();
-  set$5(rpc);
+  set$7(rpc);
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
@@ -3248,7 +3297,7 @@ const initializeRendererWorker = async () => {
   const rpc = await create({
     commandMap: commandMap
   });
-  set$2(rpc);
+  set$3(rpc);
 };
 
 const listen = async () => {

package/package.json

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