@lvce-editor/process-explorer 3.0.0 → 3.1.0

package/dist/index.js

@@ -1,55 +1,90 @@
+import { ElectronMessagePortRpcClient, WebSocketRpcParent, NodeWebSocketRpcClient, NodeWorkerRpcClient, NodeForkedProcessRpcClient, ElectronUtilityProcessRpcClient } from '@lvce-editor/rpc';
 import { object, number, string } from '@lvce-editor/assert';
-import { handleJsonRpcMessage, resolve, invoke as invoke$1 } from '@lvce-editor/json-rpc';
-import { IpcChildWithWebSocket, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess, IpcChildWithElectronUtilityProcess, IpcChildWithElectronMessagePort } from '@lvce-editor/ipc';
+import { RpcId, MainProcess, set as set$1 } from '@lvce-editor/rpc-registry';
 import { VError } from '@lvce-editor/verror';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { execFile as execFile$1 } from 'node:child_process';
 import { promisify } from 'node:util';
 
-const state$1 = {
-  commands: Object.create(null)
+const state = {
+  commandMap: {}
 };
-const registerCommand = (key, fn) => {
-  state$1.commands[key] = fn;
+const set = commandMap => {
+  state.commandMap = commandMap;
 };
-const registerCommands = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+const get = () => {
+  return state.commandMap;
 };
-const getCommand = key => {
-  return state$1.commands[key];
+
+const requiresSocket = () => {
+  return false;
 };
 
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`Command not found ${command}`);
+const setRpc = (rpc, rpcId) => {
+  if (typeof rpcId !== 'number') {
+    return;
   }
-  return fn(...args);
+  if (rpcId === RpcId.MainProcess) {
+    MainProcess.set(rpc);
+    return;
+  }
+  set$1(rpcId, rpc);
 };
 
-const preparePrettyError = error => {
-  return error;
+const createMessagePortRpc = async (create, messagePort) => {
+  return create({
+    commandMap: get(),
+    messagePort,
+    requiresSocket: requiresSocket
+  });
+};
+const handleMessagePort = async (messagePort, rpcId) => {
+  object(messagePort);
+  const rpc = await createMessagePortRpc(ElectronMessagePortRpcClient.create, messagePort);
+  setRpc(rpc, rpcId);
 };
-const logError = error => {
-  console.error(error);
+
+const handleElectronMessagePort = async (messagePort, rpcId) => {
+  await handleMessagePort(messagePort, rpcId);
 };
-const requiresSocket = () => {
-  return false;
+
+const createSocketRpc = async (create, webSocket) => {
+  return create({
+    commandMap: get(),
+    webSocket
+  });
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+const handleSocket = async (webSocket, rpcId) => {
+  object(webSocket);
+  const rpc = await createSocketRpc(WebSocketRpcParent.create, webSocket);
+  setRpc(rpc, rpcId);
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else {
-    // deprecated
-    ipc.on('message', handleMessage);
+const isWindows = process.platform === 'win32';
+
+const getModule$1 = async () => {
+  if (isWindows) {
+    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
   }
+  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
+};
+const listProcessesWithMemoryUsage$2 = async rootPid => {
+  const module = await getModule$1();
+  return module.listProcessesWithMemoryUsage(rootPid);
+};
+
+const getMainProcessId = () => {
+  return process.ppid;
+};
+
+const commandMap = {
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
+  'HandleSocket.handleSocket': handleSocket,
+  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
+  'ProcessId.getMainProcessId': getMainProcessId
+  // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
 };
 
 const NodeWorker = 1;
@@ -73,18 +108,18 @@ const Auto = () => {
   throw new Error(`[shared-process] unknown ipc type`);
 };
 
-const getModule$1 = method => {
+const getModule = method => {
   switch (method) {
     case ElectronMessagePort:
-      return IpcChildWithElectronMessagePort;
+      return ElectronMessagePortRpcClient.create;
     case ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess;
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess;
+      return NodeForkedProcessRpcClient.create;
     case NodeWorker:
-      return IpcChildWithNodeWorker;
+      return NodeWorkerRpcClient.create;
     case WebSocket:
-      return IpcChildWithWebSocket;
+      return NodeWebSocketRpcClient.create;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -94,81 +129,27 @@ const listen$1 = async ({
   method,
   ...params
 }) => {
-  const module = getModule$1(method);
-  // @ts-ignore
-  const rawIpc = module.listen(params);
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const MainProcess = -5;
-
-const state = {
-  ipc: undefined
-};
-const invoke = (method, ...params) => {
-  return invoke$1(state.ipc, method, ...params);
-};
-
-const handleElectronMessagePort = async (messagePort, ipcId) => {
-  object(messagePort);
-  // Assert.number(ipcId)
-  const ipc = await listen$1({
-    messagePort,
-    method: ElectronMessagePort
-  });
-  handleIpc(ipc);
-  if (ipcId === MainProcess) {
-    state.ipc = ipc;
-  }
-};
-
-const isWindows = process.platform === 'win32';
-
-const getModule = async () => {
-  if (isWindows) {
-    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
-  }
-  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
-};
-const listProcessesWithMemoryUsage$2 = async rootPid => {
-  const module = await getModule();
-  return module.listProcessesWithMemoryUsage(rootPid);
-};
-
-const getMainProcessId = () => {
-  return process.ppid;
-};
-
-const commandMap = {
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
-  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
-  'ProcessId.getMainProcessId': getMainProcessId
-  // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
+  const create = getModule(method);
+  const rpc = await create(params);
+  return rpc;
 };
 
 const listen = async () => {
-  const ipc = await listen$1({
+  set(commandMap);
+  await listen$1({
+    commandMap: commandMap,
     method: Auto()
   });
-  handleIpc(ipc);
 };
 
 const main = async () => {
-  registerCommands(commandMap);
   await listen();
 };
 
 main();
 
 const createPidMap = async () => {
-  return invoke('CreatePidMap.createPidMap');
+  return MainProcess.invoke('CreatePidMap.createPidMap');
 };
 
 const processNamePatterns = [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
-    "@lvce-editor/ipc": "^16.0.0",
-    "@lvce-editor/json-rpc": "^8.0.0",
+    "@lvce-editor/rpc": "^6.4.0",
+    "@lvce-editor/rpc-registry": "^9.27.0",
     "@lvce-editor/verror": "^1.7.0"
   },
   "optionalDependencies": {