@lvce-editor/pty-host 3.2.0 → 4.1.0

package/dist/ptyHostMain.js

@@ -1,6 +1,7 @@
-import { execute, register } from '@lvce-editor/command';
+import { register, execute } from '@lvce-editor/command';
+import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
+import * as JsonRpc from '@lvce-editor/json-rpc';
 import { handleJsonRpcMessage, resolve } from '@lvce-editor/json-rpc';
-import { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithWebSocket, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
 import debugModule from 'debug';
 import { spawn } from 'node-pty';
 import { VError } from '@lvce-editor/verror';
@@ -9,6 +10,131 @@ import { createWriteStream } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { prepare } from '@lvce-editor/pretty-error';
 
+const createRpc = ipc => {
+  const rpc = {
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      JsonRpc.send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return JsonRpc.invoke(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return JsonRpc.invokeAndTransfer(ipc, method, ...params);
+    },
+    async dispose() {
+      await ipc?.dispose();
+    }
+  };
+  return rpc;
+};
+const requiresSocket$1 = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$2 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$e = async ({
+  commandMap,
+  messagePort,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithElectronMessagePort, {
+    messagePort
+  });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const ElectronMessagePortRpcClient = {
+  __proto__: null,
+  create: create$e
+};
+const create$d = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithElectronUtilityProcess);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const ElectronUtilityProcessRpcClient = {
+  __proto__: null,
+  create: create$d
+};
+const create$7 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithNodeForkedProcess);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const NodeForkedProcessRpcClient = {
+  __proto__: null,
+  create: create$7
+};
+const create$5 = async ({
+  commandMap,
+  request,
+  handle,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithWebSocket, {
+    request,
+    handle
+  });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const NodeWebSocketRpcClient = {
+  __proto__: null,
+  create: create$5
+};
+
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -62,32 +188,12 @@ const string = value => {
   }
 };
 
-const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create']);
-const requiresSocket = method => {
-  return METHODS_THAT_REQUIRE_SOCKET.has(method);
-};
-
-const preparePrettyError = error => {
-  return error;
-};
-const logError = () => {
-  // PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
-};
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
-};
-
-const handleIpc = ipc => {
-  object(ipc);
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('onmessage' in ipc) {
-    // deprecated
-    ipc.onmessage = handleMessage;
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
+const handleElectronMessagePort = async messagePort => {
+  object(messagePort);
+  await ElectronMessagePortRpcClient.create({
+    commandMap: {},
+    messagePort
+  });
 };
 
 const NodeWorker = 1;
@@ -115,15 +221,13 @@ const Auto = () => {
 const getModule = method => {
   switch (method) {
     case NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess;
-    case NodeWorker:
-      return IpcChildWithNodeWorker;
+      return NodeForkedProcessRpcClient;
     case WebSocket:
-      return IpcChildWithWebSocket;
+      return NodeWebSocketRpcClient;
     case ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess;
+      return ElectronUtilityProcessRpcClient;
     case ElectronMessagePort:
-      return IpcChildWithElectronMessagePort;
+      return ElectronMessagePortRpcClient;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -135,43 +239,31 @@ const listen$1 = async ({
 }) => {
   const module = getModule(method);
   // @ts-ignore
-  const rawIpc = await module.listen(params);
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const handleElectronMessagePort = async messagePort => {
-  object(messagePort);
-  const ipc = await listen$1({
-    method: ElectronMessagePort,
-    messagePort
-  });
-  handleIpc(ipc);
+  const rpc = await module.create(params);
+  return rpc;
 };
 
 const handleNodeMessagePort = async messagePort => {
-  const ipc = await listen$1({
+  await listen$1({
     method: NodeMessagePort,
     messagePort
   });
-  handleIpc(ipc);
+};
+
+const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create']);
+const requiresSocket = method => {
+  return METHODS_THAT_REQUIRE_SOCKET.has(method);
 };
 
 const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
-  const ipc = await listen$1({
-    method: WebSocket,
+  await NodeWebSocketRpcClient.create({
+    commandMap: {},
+    handle,
     request,
-    handle
+    requiresSocket: requiresSocket
   });
-  handleIpc(ipc);
 };
 
 const debug = debugModule('pty-host');
@@ -324,10 +416,9 @@ const commandMap = {
 };
 
 const listen = async () => {
-  const ipc = await listen$1({
+  await listen$1({
     method: Auto()
   });
-  handleIpc(ipc);
 };
 
 const NewLine = '\n';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/pty-host",
-  "version": "3.2.0",
+  "version": "4.1.0",
   "description": "",
   "keywords": [
     "lvce-editor",
@@ -18,12 +18,12 @@
   "dependencies": {
     "@lvce-editor/assert": "^1.3.0",
     "@lvce-editor/command": "^1.2.0",
-    "@lvce-editor/ipc": "^13.8.0",
+    "@lvce-editor/ipc": "^14.1.0",
     "@lvce-editor/json-rpc": "^5.4.0",
     "@lvce-editor/pretty-error": "^2.0.0",
-    "@lvce-editor/rpc": "^1.27.0",
+    "@lvce-editor/rpc": "^3.4.0",
     "@lvce-editor/verror": "^1.6.0",
-    "debug": "^4.4.0"
+    "debug": "^4.4.1"
   },
   "optionalDependencies": {
     "node-pty": "^1.1.0-beta34"