@lvce-editor/process-explorer 2.2.0 → 2.3.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
-import { object, number as number$1, string } from '@lvce-editor/assert';
+import { object, number, string } from '@lvce-editor/assert';
 import { VError } from '@lvce-editor/verror';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -7,95 +7,45 @@ import { execFile as execFile$1 } from 'node:child_process';
 import { promisify } from 'node:util';
 
 const Two = '2.0';
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
+const state$2 = {
   callbacks: Object.create(null)
 };
 const set = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  state$2.callbacks[id] = fn;
 };
 const get = id => {
-  return state$1$1.callbacks[id];
+  return state$2.callbacks[id];
 };
 const remove = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$2 = {
-  id: 0
+  delete state$2.callbacks[id];
 };
+let id = 0;
 const create$3 = () => {
-  return ++state$2.id;
+  return ++id;
 };
 const warn = (...args) => {
   console.warn(...args);
 };
-const withResolvers$1 = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
 const registerPromise = () => {
   const id = create$3();
   const {
     resolve,
     promise
-  } = withResolvers$1();
+  } = Promise.withResolvers();
   set(id, resolve);
   return {
     id,
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove(id);
 };
 const create$2 = (method, params) => {
@@ -245,14 +195,16 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-const create$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
-};
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -267,11 +219,19 @@ const getErrorProperty = (error, prettyError) => {
     data: {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
-      type: prettyError.type,
-      code: prettyError.code
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
     }
   };
 };
+const create$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
+};
 const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
@@ -307,32 +267,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -353,15 +323,19 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invoke$1 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2(method, params);
-  ipc.send(message);
+  {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const invoke$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params);
 };
 
 const state$1 = {
@@ -525,9 +499,9 @@ const main = async () => {
 main();
 
 const getName = (pid, cmd, rootPid, pidMap) => {
-  number$1(pid);
+  number(pid);
   string(cmd);
-  number$1(rootPid);
+  number(rootPid);
   object(pidMap);
   if (pid === rootPid) {
     return 'main';
@@ -739,7 +713,7 @@ const getContent = async pid => {
 };
 const getAccurateMemoryUsage = async pid => {
   try {
-    number$1(pid);
+    number(pid);
     if (isMacOs) {
       return 0;
     }
@@ -807,7 +781,7 @@ const parsePsOutputLine = line => {
 };
 const parsePsOutput = (stdout, rootPid, pidMap) => {
   string(stdout);
-  number$1(rootPid);
+  number(rootPid);
   object(pidMap);
   if (stdout === EmptyString) {
     return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -19,9 +19,9 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.3.0",
-    "@lvce-editor/ipc": "^10.0.4",
-    "@lvce-editor/json-rpc": "^3.0.0",
-    "@lvce-editor/verror": "^1.4.0"
+    "@lvce-editor/ipc": "^11.4.0",
+    "@lvce-editor/json-rpc": "^5.2.0",
+    "@lvce-editor/verror": "^1.6.0"
   },
   "optionalDependencies": {
     "@vscode/windows-process-tree": "^0.6.0"