@lvce-editor/pty-host 8.8.0 → 8.9.0

package/dist/ptyHostMain.js

@@ -1378,88 +1378,6 @@ const NodeWebSocketRpcClient = {
   create: create$2
 };
 
-const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create']);
-const requiresSocket = method => {
-  return METHODS_THAT_REQUIRE_SOCKET.has(method);
-};
-
-const handleElectronMessagePort = async messagePort => {
-  object(messagePort);
-  await create$5({
-    commandMap: {},
-    messagePort,
-    requiresSocket: requiresSocket
-  });
-};
-
-const NodeWorker = 1;
-const NodeForkedProcess = 2;
-const WebSocket = 3;
-const ElectronUtilityProcess = 4;
-const ElectronMessagePort = 5;
-const NodeMessagePort = 6;
-const Auto = () => {
-  const {
-    argv
-  } = process;
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker;
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess;
-  }
-  if (argv.includes('--ipc-type=websocket')) {
-    return WebSocket;
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess;
-  }
-  throw new Error(`[pty-host] unknown ipc type`);
-};
-
-const getModule = method => {
-  switch (method) {
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient;
-    case NodeForkedProcess:
-      return NodeForkedProcessRpcClient;
-    case WebSocket:
-      return NodeWebSocketRpcClient;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const listen$1 = async ({
-  method,
-  ...params
-}) => {
-  const module = getModule(method);
-  // @ts-ignore
-  const rpc = await module.create(params);
-  return rpc;
-};
-
-const handleNodeMessagePort = async messagePort => {
-  await listen$1({
-    messagePort,
-    method: NodeMessagePort
-  });
-};
-
-const handleWebSocket = async (handle, request) => {
-  object(handle);
-  object(request);
-  await create$2({
-    commandMap: {},
-    handle,
-    request,
-    requiresSocket: requiresSocket
-  });
-};
-
 class DataEvent extends Event {
   constructor(data) {
     super('data');
@@ -1539,63 +1457,251 @@ const create$1 = async ({
   }
 };
 
-const state$1 = {
-  ptyMap: Object.create(null)
-};
-const set = (id, pty) => {
-  state$1.ptyMap[id] = pty;
+const connections$1 = new WeakMap();
+const set = (ipc, id, pty) => {
+  let terminals = connections$1.get(ipc);
+  if (!terminals) {
+    terminals = new Map();
+    connections$1.set(ipc, terminals);
+  }
+  terminals.set(id, pty);
 };
-const get = id => {
-  return state$1.ptyMap[id];
+const get = (ipc, id) => connections$1.get(ipc)?.get(id);
+const remove = (ipc, id) => {
+  connections$1.get(ipc)?.delete(id);
 };
-const remove = id => {
-  delete state$1.ptyMap[id];
+
+const connections = new WeakMap();
+const cleanup = new WeakMap();
+const closedConnections = new WeakSet();
+const disposeConnection = ipc => {
+  closedConnections.add(ipc);
+  const entries = connections.get(ipc);
+  connections.delete(ipc);
+  if (!entries) return;
+  for (const entry of entries) {
+    entry.closed = true;
+    if (entry.pty) {
+      cleanup.get(entry.pty)?.();
+      entry.pty.dispose();
+    }
+  }
 };
 
 // TODO maybe merge pty and pty controller
-const create = async (ipc, id, cwd, command, args) => {
+const createWithDependencies = async (ipc, id, cwd, command, args, createPty) => {
   number(id);
   string(cwd);
   string(command);
   array(args);
   object(ipc);
-  // @ts-ignore
-  const pty = await create$1({
-    args,
-    command,
-    cwd
-  });
+  if (closedConnections.has(ipc)) throw new Error('Terminal connection closed');
+  let entries = connections.get(ipc);
+  if (!entries) {
+    entries = new Set();
+    connections.set(ipc, entries);
+  }
+  const entry = {
+    closed: false
+  };
+  entries.add(entry);
+  let pty;
+  try {
+    pty = await createPty({
+      args,
+      command,
+      cwd
+    });
+  } catch (error) {
+    entries.delete(entry);
+    throw error;
+  }
+  entry.pty = pty;
+  if (entry.closed) {
+    pty.dispose();
+    throw new Error('Terminal connection closed');
+  }
   const handleData = event => {
+    if (entry.closed) return;
     ipc.send({
       jsonrpc: '2.0',
       method: 'Viewlet.send',
       params: [id, 'handleData', event.data]
     });
   };
+  const handleExit = event => {
+    entries.delete(entry);
+    if (get(ipc, id) === pty) remove(ipc, id);
+    if (entry.closed) return;
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'Viewlet.send',
+      params: [id, 'handleExit', event.data]
+    });
+  };
+  cleanup.set(pty, () => {
+    entry.closed = true;
+    entries.delete(entry);
+    pty.removeEventListener('data', handleData);
+    pty.removeEventListener('exit', handleExit);
+    if (get(ipc, id) === pty) remove(ipc, id);
+    cleanup.delete(pty);
+  });
   pty.addEventListener('data', handleData);
-  set(id, pty);
+  pty.addEventListener('exit', handleExit, {
+    once: true
+  });
+  set(ipc, id, pty);
+};
+const create = (ipc, id, cwd, command, args) => {
+  return createWithDependencies(ipc, id, cwd, command, args, create$1);
 };
-const write = (id, data) => {
-  const pty = get(id);
+const write = (ipc, id, data) => {
+  const pty = get(ipc, id);
   if (!pty) {
     throw new Error(`pty ${id} not found`);
   }
   pty.write(data);
 };
-const resize = (id, columns, rows) => {
-  const pty = get(id);
+const resize = (ipc, id, columns, rows) => {
+  const pty = get(ipc, id);
   if (!pty) {
     throw new Error(`pty ${id} not found`);
   }
   pty.resize(columns, rows);
 };
-const dispose = id => {
-  const pty = get(id);
+const dispose = (ipc, id) => {
+  const pty = get(ipc, id);
   if (!pty) {
-    throw new Error(`pty ${id} not found`);
+    return;
   }
+  cleanup.get(pty)?.();
   pty.dispose();
-  remove(id);
+  if (get(ipc, id) === pty) remove(ipc, id);
+};
+
+const ready = Promise.withResolvers();
+const state$1 = {};
+const setParent = rpc => {
+  state$1.parent = rpc;
+  ready.resolve();
+};
+const release = async id => {
+  if (!state$1.parent) await ready.promise;
+  state$1.parent.send('PtyHost.release', id);
+};
+const connect = async (handle, id, create) => {
+  let closed = false;
+  let rpc;
+  const onClose = () => {
+    if (closed) return;
+    closed = true;
+    handle.off('close', onClose);
+    try {
+      if (rpc) disposeConnection(rpc.ipc);
+    } finally {
+      if (id !== undefined) void release(id);
+    }
+  };
+  handle.on('close', onClose);
+  try {
+    if (handle.destroyed) throw new Error('Terminal connection closed');
+    rpc = await create();
+    if (closed) {
+      disposeConnection(rpc.ipc);
+      await rpc.dispose();
+    }
+  } catch (error) {
+    onClose();
+    handle.destroy?.();
+    handle.close?.();
+    throw error;
+  }
+};
+
+const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create', 'Terminal.write', 'Terminal.resize', 'Terminal.dispose']);
+const requiresSocket = method => {
+  return METHODS_THAT_REQUIRE_SOCKET.has(method);
+};
+
+const handleElectronMessagePort = async (messagePort, connectionId) => {
+  object(messagePort);
+  await connect(messagePort, connectionId, () => create$5({
+    commandMap: {},
+    messagePort,
+    requiresSocket: requiresSocket
+  }));
+};
+
+const NodeWorker = 1;
+const NodeForkedProcess = 2;
+const WebSocket = 3;
+const ElectronUtilityProcess = 4;
+const ElectronMessagePort = 5;
+const NodeMessagePort = 6;
+const Auto = () => {
+  const {
+    argv
+  } = process;
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker;
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess;
+  }
+  if (argv.includes('--ipc-type=websocket')) {
+    return WebSocket;
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess;
+  }
+  throw new Error(`[pty-host] unknown ipc type`);
+};
+
+const getModule = method => {
+  switch (method) {
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient;
+    case NodeForkedProcess:
+      return NodeForkedProcessRpcClient;
+    case WebSocket:
+      return NodeWebSocketRpcClient;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
+  const module = getModule(method);
+  // @ts-ignore
+  const rpc = await module.create(params);
+  if (params.requiresSocket) {
+    rpc.ipc.requiresSocket = params.requiresSocket;
+  }
+  return rpc;
+};
+
+const handleNodeMessagePort = async messagePort => {
+  await listen$1({
+    messagePort,
+    method: NodeMessagePort
+  });
+};
+
+const handleWebSocket = async (handle, request, connectionId) => {
+  object(handle);
+  object(request);
+  await connect(handle, connectionId, () => create$2({
+    commandMap: {},
+    handle,
+    request,
+    requiresSocket: requiresSocket
+  }));
 };
 
 const HandleElectronMessagePort = 'HandleElectronMessagePort.handleElectronMessagePort';
@@ -1619,9 +1725,11 @@ const commandMap = {
 };
 
 const listen = async () => {
-  await listen$1({
-    method: Auto()
+  const rpc = await listen$1({
+    method: Auto(),
+    requiresSocket: requiresSocket
   });
+  setParent(rpc);
 };
 
 const NewLine$1 = '\n';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/pty-host",
-  "version": "8.8.0",
+  "version": "8.9.0",
   "keywords": [
     "lvce-editor",
     "pty-host"