@lvce-editor/shared-process 0.26.0 → 0.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.26.0",
-    "@lvce-editor/ipc": "^5.1.0",
+    "@lvce-editor/extension-host-helper-process": "0.26.2",
+    "@lvce-editor/ipc": "^7.2.0",
     "@lvce-editor/json-rpc": "^1.3.0",
     "@lvce-editor/jsonc-parser": "^1.2.0",
     "@lvce-editor/pretty-error": "^1.5.0",
-    "@lvce-editor/pty-host": "0.26.0",
+    "@lvce-editor/pty-host": "0.26.2",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/ConnectIpcToElectron/ConnectIpcToElectron.js

@@ -0,0 +1,9 @@
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+export const connectIpcToElectron = async (ipc) => {
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
+    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', IpcId.MainProcess);
+    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
+};

package/src/parts/EmbedsProcess/EmbedsProcess.js

@@ -1,4 +1,3 @@
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
 import * as LaunchEmbedsProcess from '../LaunchEmbedsProcess/LaunchEmbedsProcess.js';
 export const state = {
     /**
@@ -12,11 +11,3 @@ export const getOrCreate = async () => {
     }
     return state.ipc;
 };
-export const invoke = async (method, ...params) => {
-    const ipc = await getOrCreate();
-    return JsonRpc.invoke(ipc, method, ...params);
-};
-export const invokeAndTransfer = async (method, transfer, ...params) => {
-    const ipc = await getOrCreate();
-    return JsonRpc.invokeAndTransfer(ipc, transfer, method, ...params);
-};

package/src/parts/EmbedsProcessPath/EmbedsProcessPath.js

@@ -1,3 +1,3 @@
 import * as Path from '../Path/Path.js';
 import * as Root from '../Root/Root.js';
-export const embedsProcessPath = Path.join(Root.root, 'packages', 'embeds-process', 'src', 'embedsProcessMain.js');
+export const embedsProcessPath = Path.join(Root.root, 'packages', 'embeds-process', 'dist', 'embedsProcessMain.js');

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -1,22 +1,11 @@
-import * as Assert from '../Assert/Assert.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as IpcChild from '../IpcChild/IpcChild.js';
-import * as IpcChildType from '../IpcChildType/IpcChildType.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-const mainProcessSpecialId = -5;
-export const handleElectronMessagePort = async (messagePort, ...params) => {
-    Assert.object(messagePort);
-    const ipc = await IpcChild.listen({
-        method: IpcChildType.ElectronMessagePort,
-        messagePort,
-    });
-    HandleIpc.handleIpc(ipc);
-    if (params[0] === mainProcessSpecialId) {
-        // update ipc with message port ipc that supports transferring objects
-        // @ts-ignore
-        ParentIpc.state.ipc = ipc;
-    }
-    // TODO find better way to associate configuration with ipc
-    // @ts-ignore
-    ipc.windowId = params[1];
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleElectronMessagePort = (messagePort, ...params) => {
+    const ipcId = params[0];
+    const windowId = params[1];
+    const message = {
+        ipcId,
+        windowId,
+    };
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.SharedProcess, messagePort, message);
 };

package/src/parts/HandleIncomingIpc/HandleIncomingIpc.js

@@ -0,0 +1,44 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as HandleIpcModule from '../HandleIpcModule/HandleIpcModule.js';
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
+import * as SendIncomingIpc from '../SendIncomingIpc/SendIncomingIpc.js';
+const handleIncomingIpcMessagePort = async (module, handle, message) => {
+    const target = await module.targetMessagePort(handle, message);
+    const response = module.upgradeMessagePort(handle, message);
+    return {
+        target,
+        response,
+    };
+};
+const handleIncomingIpcWebSocket = async (module, handle, message) => {
+    const target = await module.targetWebSocket(handle, message);
+    const response = module.upgradeWebSocket(handle, message);
+    return {
+        target,
+        response,
+    };
+};
+const getIpcAndResponse = (module, handle, message) => {
+    if (IsMessagePortMain.isMessagePortMain(handle)) {
+        return handleIncomingIpcMessagePort(module, handle, message);
+    }
+    return handleIncomingIpcWebSocket(module, handle, message);
+};
+const applyResponse = async (target, response, ipcId) => {
+    switch (response.type) {
+        case 'handle':
+            HandleIpc.handleIpc(target);
+            break;
+        case 'send':
+            return SendIncomingIpc.sendIncomingIpc(target, response, ipcId);
+        default:
+            throw new Error('unexpected response');
+    }
+};
+export const handleIncomingIpc = async (ipcId, handle, message) => {
+    Assert.number(ipcId);
+    const module = HandleIpcModule.getModule(ipcId);
+    const { target, response } = await getIpcAndResponse(module, handle, message);
+    await applyResponse(target, response, ipcId);
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,4 +1,25 @@
 import * as HandleMessage from '../HandleMessage/HandleMessage.js';
+const handled = new WeakSet();
 export const handleIpc = (ipc) => {
-    ipc.on('message', HandleMessage.handleMessage);
+    if (handled.has(ipc)) {
+        return;
+    }
+    handled.add(ipc);
+    if ('addEventListener' in ipc) {
+        ipc.addEventListener('message', HandleMessage.handleMessage);
+    }
+    else if ('on' in ipc) {
+        // deprecated
+        ipc.on('message', HandleMessage.handleMessage);
+    }
+};
+export const unhandleIpc = (ipc) => {
+    handled.delete(ipc);
+    if ('removeEventListener' in ipc) {
+        ipc.removeEventListener('message', HandleMessage.handleMessage);
+    }
+    else if ('off' in ipc) {
+        // deprecated
+        ipc.off('message', HandleMessage.handleMessage);
+    }
 };

package/src/parts/HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js

@@ -0,0 +1,12 @@
+import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
+export const targetMessagePort = () => {
+    return EmbedsProcess.getOrCreate();
+};
+export const upgradeMessagePort = (port, message) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [message.ipcId],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js

@@ -0,0 +1,30 @@
+import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const targetWebSocket = async () => {
+    const ipc = await ExtensionHostHelperProcessIpc.create({
+        method: IpcParentType.NodeForkedProcess,
+    });
+    return ipc;
+};
+export const upgradeWebSocket = (handle, message) => {
+    return {
+        type: 'send',
+        method: 'HandleWebSocket.handleWebSocket',
+        params: [message],
+        transfer: handle,
+    };
+};
+export const targetMessagePort = async () => {
+    const ipc = await ExtensionHostHelperProcessIpc.create({
+        method: IpcParentType.ElectronUtilityProcess,
+    });
+    return ipc;
+};
+export const upgradeMessagePort = (port) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcModule/HandleIpcModule.js

@@ -0,0 +1,27 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleIpcEmbedsProcess from '../HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js';
+import * as HandleIpcExtensionHostHelperProcess from '../HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js';
+import * as HandleIpcProcessExplorer from '../HandleIpcProcessExplorer/HandleIpcProcessExplorer.js';
+import * as HandleIpcSearchProcess from '../HandleIpcSearchProcess/HandleIpcSearchProcess.js';
+import * as HandleIpcSharedProcess from '../HandleIpcSharedProcess/HandleIpcSharedProcess.js';
+import * as HandleIpcTerminalProcess from '../HandleIpcTerminalProcess/HandleIpcTerminalProcess.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const getModule = (ipcId) => {
+    Assert.number(ipcId);
+    switch (ipcId) {
+        case IpcId.SharedProcess:
+            return HandleIpcSharedProcess;
+        case IpcId.EmbedsProcess:
+            return HandleIpcEmbedsProcess;
+        case IpcId.TerminalProcess:
+            return HandleIpcTerminalProcess;
+        case IpcId.ExtensionHostHelperProcess:
+            return HandleIpcExtensionHostHelperProcess;
+        case IpcId.ProcessExplorer:
+            return HandleIpcProcessExplorer;
+        case IpcId.SearchProcess:
+            return HandleIpcSearchProcess;
+        default:
+            throw new Error(`unexpected incoming ipc`);
+    }
+};

package/src/parts/HandleIpcProcessExplorer/HandleIpcProcessExplorer.js

@@ -0,0 +1,14 @@
+import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js';
+import * as Assert from '../Assert/Assert.js';
+export const targetMessagePort = () => {
+    return ProcessExplorer.getOrCreate();
+};
+export const upgradeMessagePort = (port) => {
+    Assert.object(port);
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcSearchProcess/HandleIpcSearchProcess.js

@@ -0,0 +1 @@
+export {};

package/src/parts/HandleIpcSharedProcess/HandleIpcSharedProcess.js

@@ -0,0 +1,41 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleSocketError from '../HandleSocketError/HandleSocketError.js';
+import * as IpcChild from '../IpcChild/IpcChild.js';
+import * as IpcChildType from '../IpcChildType/IpcChildType.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+export const targetWebSocket = async (handle, message) => {
+    handle.on('error', HandleSocketError.handleSocketError);
+    const ipc = await IpcChild.listen({
+        method: IpcChildType.WebSocket,
+        request: message,
+        handle,
+    });
+    return ipc;
+};
+export const upgradeWebSocket = () => {
+    return {
+        type: 'handle',
+    };
+};
+export const targetMessagePort = async (messagePort, message) => {
+    Assert.object(messagePort);
+    const ipc = await IpcChild.listen({
+        method: IpcChildType.ElectronMessagePort,
+        messagePort,
+    });
+    if (message.ipcId === IpcId.MainProcess) {
+        // update ipc with message port ipc that supports transferring objects
+        // @ts-ignore
+        ParentIpc.state.ipc = ipc;
+    }
+    // TODO find better way to associate configuration with ipc
+    // @ts-ignore
+    ipc.windowId = message.windowId;
+    return ipc;
+};
+export const upgradeMessagePort = () => {
+    return {
+        type: 'handle',
+    };
+};

package/src/parts/HandleIpcTerminalProcess/HandleIpcTerminalProcess.js

@@ -0,0 +1,24 @@
+import * as PtyHost from '../PtyHost/PtyHost.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const targetWebSocket = () => {
+    return PtyHost.getOrCreate(IpcParentType.NodeForkedProcess);
+};
+export const upgradeWebSocket = (handle, message) => {
+    return {
+        type: 'send',
+        method: 'HandleWebSocket.handleWebSocket',
+        params: [message],
+        transfer: handle,
+    };
+};
+export const targetMessagePort = () => {
+    return PtyHost.getOrCreate(IpcParentType.ElectronUtilityProcess);
+};
+export const upgradeMessagePort = (port) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.js

@@ -1,8 +1,7 @@
-import * as Assert from '../Assert/Assert.js';
-import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-export const handleMessagePortForEmbedsProcess = async (port) => {
-    Assert.object(port);
-    const embedsProcess = await EmbedsProcess.getOrCreate();
-    await JsonRpc.invokeAndTransfer(embedsProcess, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForEmbedsProcess = (port, ipcId) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.EmbedsProcess, port, {
+        ipcId,
+    });
 };

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.js

@@ -15,9 +15,9 @@ export const handleMessagePortForExtensionHostHelperProcess = async (rendererWor
     });
     HandleIpc.handleIpc(ipc);
     await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
-    const cleanup = () => {
-        ipc.dispose();
-        rendererWorkerIpc.off('close', cleanup);
-    };
-    rendererWorkerIpc.on('close', cleanup);
+    // const cleanup = () => {
+    //   ipc.dispose()
+    //   rendererWorkerIpc.off('close', cleanup)
+    // }
+    // rendererWorkerIpc.on('close', cleanup)
 };

package/src/parts/HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.js

@@ -1,8 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js';
-export const handleMessagePortForProcessExplorer = async (port) => {
-    Assert.object(port);
-    const ipc = await ProcessExplorer.getOrCreate();
-    await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForProcessExplorer = (port) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.ProcessExplorer, port, {});
 };

package/src/parts/HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.js

@@ -1,9 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as PtyHost from '../PtyHost/PtyHost.js';
-export const handleMessagePortForTerminalProcess = async (port) => {
-    Assert.object(port);
-    const ptyHost = await PtyHost.getOrCreate(IpcParentType.ElectronUtilityProcess);
-    await JsonRpc.invokeAndTransfer(ptyHost, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForTerminalProcess = (port) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.TerminalProcess, port, {});
 };

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -1,9 +1,5 @@
-import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js';
-import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-export const handleWebSocket = async (message, handle) => {
-    const ipc = await ExtensionHostHelperProcessIpc.create({
-        method: IpcParentType.NodeForkedProcess,
-    });
-    await JsonRpc.invokeAndTransfer(ipc, handle, 'HandleWebSocket.handleWebSocket', message);
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (message, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.ExtensionHostHelperProcess, handle, message);
 };

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -1,16 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as HandleSocketError from '../HandleSocketError/HandleSocketError.js';
-import * as IpcChild from '../IpcChild/IpcChild.js';
-import * as IpcChildType from '../IpcChildType/IpcChildType.js';
-export const handleWebSocket = async (request, handle) => {
-    Assert.object(request);
-    Assert.object(handle);
-    handle.on('error', HandleSocketError.handleSocketError);
-    const ipc = await IpcChild.listen({
-        method: IpcChildType.WebSocket,
-        request,
-        handle,
-    });
-    HandleIpc.handleIpc(ipc);
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (request, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.SharedProcess, handle, request);
 };

package/src/parts/HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js

@@ -1,18 +1,5 @@
-import * as PtyHost from '../PtyHost/PtyHost.js';
-export const handleWebSocket = async (message, handle) => {
-    const instance = await PtyHost.getOrCreate();
-    instance.sendAndTransfer({
-        jsonrpc: '2.0',
-        method: 'HandleWebSocket.handleWebSocket',
-        params: [message],
-    }, handle);
-    // console.log({ instance })
-    // const ipc = await PtyHost.getOrCreate()
-    // console.info('[sharedprocess] creating extension ipc')
-    // const rpc = await ExtensionHostRpc.create(ipc, handle)
-    // console.info('[sharedprocess] created extension host rpc')
-    // ipc._process.send(message, handle)
-    // rpc.send(message)
-    // console.log('spawned extension host')
-    // console.log(rpc)
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (message, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.TerminalProcess, handle, message);
 };

package/src/parts/IpcId/IpcId.js

@@ -0,0 +1,8 @@
+export const SharedProcess = 1;
+export const MainProcess = -5;
+export const EmbedsProcess = 2;
+export const TerminalProcess = 7;
+export const ExtensionHostHelperProcess = 3;
+export const ProcessExplorer = 11;
+export const SearchProcess = 13;
+export const Unknown = 0;

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -22,6 +22,7 @@ export const signal = (port) => {
 export const wrap = (port) => {
     return {
         port,
+        wrappedListener: undefined,
         send(message) {
             this.port.postMessage(message);
         },
@@ -34,20 +35,33 @@ export const wrap = (port) => {
                     this.port.on(event, listener);
                     break;
                 case 'message':
-                    const wrapped = (event) => {
+                    // @ts-ignore
+                    this.wrappedListener = (event) => {
                         const syntheticEvent = {
                             data: event.data,
                             target: this,
                         };
                         listener(syntheticEvent);
                     };
-                    this.port.on(event, wrapped);
+                    this.port.on(event, this.wrappedListener);
+                    break;
+                default:
+                    break;
+            }
+        },
+        off(event, listener) {
+            switch (event) {
+                case 'close':
+                    this.port.off(event, listener);
+                    break;
+                case 'message':
+                    this.port.off(event, this.wrappedListener);
+                    this.wrappedListener = undefined;
                     break;
                 default:
                     break;
             }
         },
-        off(event, listener) { },
         dispose() {
             this.port.close();
             ParentIpc.invoke('TemporaryMessagePort.dispose', this.port.name);

package/src/parts/LaunchEmbedsProcess/LaunchEmbedsProcess.js

@@ -1,21 +1,18 @@
+import * as ConnectIpcToElectron from '../ConnectIpcToElectron/ConnectIpcToElectron.js';
 import * as EmbedsProcessPath from '../EmbedsProcessPath/EmbedsProcessPath.js';
-import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
 import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 export const launchEmbedsProcess = async () => {
-    const embedsProcess = await IpcParent.create({
+    const ipc = await IpcParent.create({
         method: IpcParentType.ElectronUtilityProcess,
         path: EmbedsProcessPath.embedsProcessPath,
         argv: [],
         stdio: 'inherit',
         name: 'Embeds Process',
     });
-    HandleIpc.handleIpc(embedsProcess);
-    const { port1, port2 } = await GetPortTuple.getPortTuple();
-    await JsonRpc.invokeAndTransfer(embedsProcess, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', /* isElectron */ true);
-    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
-    return embedsProcess;
+    HandleIpc.handleIpc(ipc);
+    await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    HandleIpc.unhandleIpc(ipc);
+    return ipc;
 };

package/src/parts/LaunchProcessExplorer/LaunchProcessExplorer.js

@@ -1,9 +1,7 @@
-import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as ConnectIpcToElectron from '../ConnectIpcToElectron/ConnectIpcToElectron.js';
 import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as ProcessExplorerPath from '../ProcessExplorerPath/ProcessExplorerPath.js';
 export const launchProcessExplorer = async () => {
     const ipc = await IpcParent.create({
@@ -11,11 +9,10 @@ export const launchProcessExplorer = async () => {
         path: ProcessExplorerPath.processExplorerPath,
         argv: [],
         stdio: 'inherit',
-        name: 'Process Process',
+        name: 'Process Explorer',
     });
     HandleIpc.handleIpc(ipc);
-    const { port1, port2 } = await GetPortTuple.getPortTuple();
-    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort');
-    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
+    await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    HandleIpc.unhandleIpc(ipc);
     return ipc;
 };

package/src/parts/LaunchPtyHost/LaunchPtyHost.js

@@ -1,6 +1,5 @@
 import exitHook from 'exit-hook';
 import * as Debug from '../Debug/Debug.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js';
 import * as PtyHostState from '../PtyHostState/PtyHostState.js';
@@ -24,14 +23,16 @@ export const launchPtyHost = async (method) => {
         stdio: 'inherit',
         name: 'Terminal Process',
     });
-    HandleIpc.handleIpc(ptyHost);
-    const handleClose = () => {
-        // @ts-ignore
-        ptyHost.off('close', handleClose);
-        PtyHostState.state.ipc = undefined;
-        PtyHostState.state.ptyHostPromise = undefined;
-    };
-    ptyHost.on('close', handleClose);
+    // HandleIpc.handleIpc(ptyHost)
+    // TODO
+    // const handleClose = () => {
+    //   // @ts-ignore
+    //   ptyHost._rawIpc.off('close', handleClose)
+    //   PtyHostState.state.ipc = undefined
+    //   PtyHostState.state.ptyHostPromise = undefined
+    // }
+    // // @ts-ignore
+    // ptyHost._rawIpc.on('close', handleClose)
     PtyHostState.state.ipc = ptyHost;
     return ptyHost;
 };

package/src/parts/Module/Module.js

@@ -5,8 +5,6 @@ export const load = (moduleId) => {
             return import('../AttachDebugger/AttachDebugger.ipc.js');
         case ModuleId.AutoUpdater:
             return import('../AutoUpdater/AutoUpdater.ipc.js');
-        case ModuleId.ElectronBrowserViewFunctions:
-            return import('../ElectronBrowserViewFunctions/ElectronBrowserViewFunctions.ipc.js');
         case ModuleId.AutoUpdaterAppImage:
             return import('../AutoUpdaterAppImage/AutoUpdaterAppImage.ipc.js');
         case ModuleId.GetWindowId:
@@ -27,8 +25,6 @@ export const load = (moduleId) => {
             return import('../Download/Download.ipc.js');
         case ModuleId.ElectronApplicationMenu:
             return import('../ElectronApplicationMenu/ElectronApplicationMenu.ipc.js');
-        case ModuleId.ElectronBrowserView:
-            return import('../ElectronBrowserView/ElectronBrowserView.ipc.js');
         case ModuleId.ElectronContentTracing:
             return import('../ElectronContentTracing/ElectronContentTracing.ipc.js');
         case ModuleId.ElectronDeveloper:
@@ -47,8 +43,6 @@ export const load = (moduleId) => {
             return import('../ElectronSafeStorage/ElectronSafeStorage.ipc.js');
         case ModuleId.Window:
             return import('../ElectronWindow/ElectronWindow.ipc.js');
-        case ModuleId.ElectronBrowserViewQuickPick:
-            return import('../ElectronBrowserViewQuickPick/ElectronBrowserViewQuickPick.ipc.js');
         case ModuleId.ElectronWindowAbout:
             return import('../ElectronWindowAbout/ElectronWindowAbout.ipc.js');
         case ModuleId.ElectronWindowProcessExplorer:
@@ -111,8 +105,6 @@ export const load = (moduleId) => {
             return import('../TextDocument/TextDocument.ipc.js');
         case ModuleId.Search:
             return import('../TextSearch/TextSearch.ipc.js');
-        case ModuleId.ElectronBrowserViewSuggestions:
-            return import('../ElectronBrowserViewSuggestions/ElectronBrowserViewSuggestions.ipc.js');
         case ModuleId.WebSocketServer:
             return import('../WebSocketServer/WebSocketServer.ipc.js');
         case ModuleId.Workspace:
@@ -137,12 +129,6 @@ export const load = (moduleId) => {
             return import('../HandleRemoteRequest/HandleRemoteRequest.ipc.js');
         case ModuleId.HandleMessagePortForExtensionHostHelperProcess:
             return import('../HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js');
-        case ModuleId.ElectronWebContents:
-            return import('../ElectronWebContents/ElectronWebContents.ipc.js');
-        case ModuleId.ElectronWebContentsView:
-            return import('../ElectronWebContentsView/ElectronWebContentsView.ipc.js');
-        case ModuleId.ElectronWebContentsViewFunctions:
-            return import('../ElectronWebContentsViewFunctions/ElectronWebContentsViewFunctions.ipc.js');
         case ModuleId.ContentSecurityPolicy:
             return import('../ContentSecurityPolicy/ContentSecurityPolicy.ipc.js');
         case ModuleId.HandleMessagePortForProcessExplorer:

package/src/parts/ModuleId/ModuleId.js

@@ -1,4 +1,3 @@
-export const ElectronBrowserViewSuggestions = 111;
 export const ClipBoard = 1;
 export const Developer = 2;
 export const ExtensionHost = 3;
@@ -22,7 +21,6 @@ export const Download = 19;
 export const ElectronPowerSaveBlocker = 222;
 export const GitLsFiles = 20;
 export const BulkReplacement = 21;
-export const ElectronBrowserViewQuickPick = 999;
 export const InstallExtension = 22;
 export const AutoUpdater = 23;
 export const IsAutoUpdateSupported = 24;
@@ -32,7 +30,6 @@ export const RebuildNodePty = 27;
 export const ElectronInitialize = 28;
 export const HandleWebSocket = 29;
 export const Process = 30;
-export const ElectronBrowserViewFunctions = 200;
 export const AttachDebugger = 31;
 export const HandleElectronMessagePort = 32;
 export const HandleNodeMessagePort = 33;
@@ -53,7 +50,6 @@ export const ElectronSafeStorage = 47;
 export const ElectronDeveloper = 100;
 export const ElectronProcess = 48;
 export const ElectronContextMenu = 49;
-export const ElectronBrowserView = 50;
 export const Window = 51;
 export const PassThroughElectronMessagePort = 52;
 export const Exit = 53;
@@ -69,9 +65,6 @@ export const TemporaryMessagePort = 62;
 export const GetElectronFileResponse = 63;
 export const HandleRemoteRequest = 64;
 export const HandleMessagePortForExtensionHostHelperProcess = 65;
-export const ElectronWebContents = 66;
-export const ElectronWebContentsView = 67;
-export const ElectronWebContentsViewFunctions = 68;
 export const HandleRequestTest = 69;
 export const ContentSecurityPolicy = 70;
 export const HandleMessagePortForEmbedsProcess = 72;

package/src/parts/ModuleMap/ModuleMap.js

@@ -41,10 +41,6 @@ export const getModuleId = (commandId) => {
         case 'ElectronApplicationMenu.handleClick':
         case 'ElectronApplicationMenu.setItems':
             return ModuleId.ElectronApplicationMenu;
-        case 'ElectronBrowserView.createBrowserView':
-        case 'ElectronBrowserView.disposeBrowserView':
-        case 'ElectronBrowserView.getAll':
-            return ModuleId.ElectronBrowserView;
         case 'ElectronClipBoard.writeText':
             return ModuleId.ElectronClipBoard;
         case 'ElectronContentTracing.startRecording':
@@ -73,9 +69,6 @@ export const getModuleId = (commandId) => {
             return ModuleId.ElectronWindowProcessExplorer;
         case 'Exit.exit':
             return ModuleId.Exit;
-        case 'ElectronBrowserViewQuickPick.createBrowserViewQuickPick':
-        case 'ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick':
-            return ModuleId.ElectronBrowserViewQuickPick;
         case 'ExtensionHost.dispose':
         case 'ExtensionHost.enableExtension':
         case 'ExtensionHost.executeCommand':
@@ -136,34 +129,6 @@ export const getModuleId = (commandId) => {
         case 'ExtensionManagement.install':
         case 'ExtensionManagement.uninstall':
             return ModuleId.ExtensionManagement;
-        case 'ElectronBrowserViewFunctions.resizeBrowserView':
-        case 'ElectronBrowserViewFunctions.setIframeSrc':
-        case 'ElectronBrowserViewFunctions.focus':
-        case 'ElectronBrowserViewFunctions.openDevtools':
-        case 'ElectronBrowserViewFunctions.reload':
-        case 'ElectronBrowserViewFunctions.forward':
-        case 'ElectronBrowserViewFunctions.backward':
-        case 'ElectronBrowserViewFunctions.cancelNavigation':
-        case 'ElectronBrowserViewFunctions.hide':
-        case 'ElectronBrowserViewFunctions.inspectElement':
-        case 'ElectronBrowserViewFunctions.copyImageAt':
-        case 'ElectronBrowserViewFunctions.setFallthroughKeyBindings':
-        case 'ElectronBrowserViewFunctions.getStats':
-            return ModuleId.ElectronBrowserViewFunctions;
-        case 'ElectronWebContentsViewFunctions.resizeBrowserView':
-        case 'ElectronWebContentsViewFunctions.setIframeSrc':
-        case 'ElectronWebContentsViewFunctions.focus':
-        case 'ElectronWebContentsViewFunctions.openDevtools':
-        case 'ElectronWebContentsViewFunctions.reload':
-        case 'ElectronWebContentsViewFunctions.forward':
-        case 'ElectronWebContentsViewFunctions.backward':
-        case 'ElectronWebContentsViewFunctions.cancelNavigation':
-        case 'ElectronWebContentsViewFunctions.hide':
-        case 'ElectronWebContentsViewFunctions.inspectElement':
-        case 'ElectronWebContentsViewFunctions.copyImageAt':
-        case 'ElectronWebContentsViewFunctions.setFallthroughKeyBindings':
-        case 'ElectronWebContentsViewFunctions.getStats':
-            return ModuleId.ElectronWebContentsViewFunctions;
         case 'FileSystem.chmod':
         case 'FileSystem.copy':
         case 'FileSystem.createFile':
@@ -177,10 +142,6 @@ export const getModuleId = (commandId) => {
         case 'FileSystem.rename':
         case 'FileSystem.writeFile':
             return ModuleId.FileSystem;
-        case 'ElectronBrowserViewSuggestions.createBrowserView':
-        case 'ElectronBrowserViewSuggestions.disposeBrowserView':
-        case 'ElectronBrowserViewSuggestions.setSuggestions':
-            return ModuleId.ElectronBrowserViewSuggestions;
         case 'GetTerminalSpawnOptions.getTerminalSpawnOptions':
             return ModuleId.GetTerminalSpawnOptions;
         case 'GitLsFiles.gitLsFiles':
@@ -301,7 +262,7 @@ export const getModuleId = (commandId) => {
             return ModuleId.HandleWindowAllClosed;
         case 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess':
             return ModuleId.HandleMessagePortForTerminalProcess;
-        case 'TemporaryMessagePort.handlePort':
+        case 'TemporaryMessagePort.handlePorts':
             return ModuleId.TemporaryMessagePort;
         case 'GetElectronFileResponse.getElectronFileResponse':
             return ModuleId.GetElectronFileResponse;
@@ -309,17 +270,6 @@ export const getModuleId = (commandId) => {
             return ModuleId.HandleRemoteRequest;
         case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
             return ModuleId.HandleMessagePortForExtensionHostHelperProcess;
-        case 'ElectronWebContents.dispose':
-        case 'ElectronWebContents.handleKeyBinding':
-        case 'ElectronWebContents.handleWindowOpen':
-        case 'ElectronWebContents.handleWillNavigate':
-        case 'ElectronWebContents.handleDidNavigate':
-        case 'ElectronWebContents.handleContextMenu':
-        case 'ElectronWebContents.handlePageTitleUpdated':
-            return ModuleId.ElectronWebContents;
-        case 'ElectronWebContentsView.createWebContentsView':
-        case 'ElectronWebContentsView.disposeWebContentsView':
-            return ModuleId.ElectronWebContentsView;
         case 'HandleRequestTest.handleRequestTest':
             return ModuleId.HandleRequestTest;
         case 'ContentSecurityPolicy.set':

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.26.0';
-export const commit = '019c142';
-export const date = '2024-04-20T21:44:51.000Z';
+export const version = '0.26.2';
+export const commit = 'efc5b0f';
+export const date = '2024-04-23T20:38:06.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/SendIncomingIpc/SendIncomingIpc.js

@@ -0,0 +1,46 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+const state = {
+    pendingCount: Object.create(null),
+};
+const addState = (ipcId) => {
+    state.pendingCount[ipcId] ||= 0;
+    state.pendingCount[ipcId]++;
+};
+const removeState = (ipcId) => {
+    state.pendingCount[ipcId]--;
+    if (state.pendingCount[ipcId] === 0) {
+        delete state.pendingCount[ipcId];
+    }
+};
+const hasState = (ipcId) => {
+    return ipcId in state.pendingCount;
+};
+const supportsPartialIpcHandling = (ipcId) => {
+    switch (ipcId) {
+        case IpcId.TerminalProcess:
+        case IpcId.ProcessExplorer:
+        case IpcId.EmbedsProcess:
+            return true;
+        default:
+            return false;
+    }
+};
+// TODO fork ipc object instead of ref counting
+// duplicated ipc object sends and receives one message
+// original ipc object is never used and can
+// be collected after being out of scope
+// duplicated ipc can also be collected
+// when it is out of scope
+export const sendIncomingIpc = async (target, response, ipcId) => {
+    if (!hasState(ipcId) && supportsPartialIpcHandling(ipcId)) {
+        HandleIpc.handleIpc(target);
+    }
+    addState(ipcId);
+    await JsonRpc.invokeAndTransfer(target, response.transfer, response.method, ...response.params);
+    removeState(ipcId);
+    if (!hasState(ipcId) && supportsPartialIpcHandling(ipcId)) {
+        HandleIpc.unhandleIpc(target);
+    }
+};

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.ipc.js

@@ -1,5 +1,5 @@
 import * as TemporaryMessagePort from './TemporaryMessagePort.js';
 export const name = 'TemporaryMessagePort';
 export const Commands = {
-    handlePort: TemporaryMessagePort.handlePort,
+    handlePorts: TemporaryMessagePort.handlePorts,
 };

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -1,26 +1,17 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as Assert from '../Assert/Assert.js';
 import * as Id from '../Id/Id.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 export const state = {
     ports: Object.create(null),
 };
-export const create = async (name) => {
-    Assert.string(name);
-    await ParentIpc.invoke('TemporaryMessagePort.create', name);
-    const port = state.ports[name];
-    if (!port) {
-        throw new Error(`port was not created`);
-    }
-    delete state.ports[name];
-    port.start();
-    return port;
-};
 export const getPortTuple = async () => {
-    const id1 = `${Id.create()}`;
-    const id2 = `${Id.create()}`;
+    const id1 = Id.create();
+    const id2 = Id.create();
     await ParentIpc.invoke('TemporaryMessagePort.createPortTuple', id1, id2);
     const port1 = state.ports[id1];
     const port2 = state.ports[id2];
+    delete state.ports[id1];
+    delete state.ports[id2];
     return {
         port1,
         port2,
@@ -31,8 +22,11 @@ export const sendTo = async (name, port) => {
     Assert.object(port);
     await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', [port], name);
 };
-export const handlePort = (port, name) => {
-    Assert.string(name);
-    Assert.object(port);
-    state.ports[name] = port;
+export const handlePorts = (port1, port2, id1, id2) => {
+    Assert.number(id1);
+    Assert.number(id2);
+    Assert.object(port1);
+    Assert.object(port2);
+    state.ports[id1] = port1;
+    state.ports[id2] = port2;
 };

package/src/parts/ElectronBrowserView/ElectronBrowserView.ipc.js

@@ -1,6 +0,0 @@
-import * as ElectronBrowserView from './ElectronBrowserView.js';
-export const name = 'ElectronBrowserView';
-export const Commands = {
-    createBrowserView: ElectronBrowserView.createBrowserView,
-    disposeBrowserView: ElectronBrowserView.disposeBrowserView,
-};

package/src/parts/ElectronBrowserView/ElectronBrowserView.js

@@ -1,21 +0,0 @@
-import * as ElectronBrowserViewIpcState from '../ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js';
-import * as ElectronBrowserViewState from '../ElectronBrowserViewState/ElectronBrowserViewState.js';
-import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-export const createBrowserView = async (ipc, restoreId, fallthroughKeyBindings) => {
-    const webContentsId = await ParentIpc.invoke('ElectronBrowserView.createBrowserView2', restoreId);
-    ElectronBrowserViewIpcState.add(webContentsId, ipc);
-    // TODO get window id from renderer worker
-    await ParentIpc.invoke('ElectronBrowserView.attachEventListeners', webContentsId);
-    await ParentIpc.invoke('ElectronBrowserViewFunctions.setBackgroundColor', webContentsId, 'white');
-    return webContentsId;
-};
-export const disposeBrowserView = async (id) => {
-    ElectronBrowserViewState.remove(id);
-    await ParentIpc.invoke('ElectronBrowserView.disposeBrowserView', id);
-    await ElectronWebContents.dispose(id);
-};
-export const handleBrowserViewCreated = (id) => {
-    console.log('created', id);
-    ElectronBrowserViewState.add(id);
-};

package/src/parts/ElectronBrowserViewFunctions/ElectronBrowserViewFunctions.ipc.js

@@ -1,18 +0,0 @@
-import * as ElectronBrowserViewFunctions from './ElectronBrowserViewFunctions.js';
-export const name = 'ElectronBrowserViewFunctions';
-export const Commands = {
-    resizeBrowserView: ElectronBrowserViewFunctions.resizeBrowserView,
-    setIframeSrc: ElectronBrowserViewFunctions.setIframeSrc,
-    focus: ElectronBrowserViewFunctions.focus,
-    openDevtools: ElectronBrowserViewFunctions.openDevtools,
-    reload: ElectronBrowserViewFunctions.reload,
-    forward: ElectronBrowserViewFunctions.forward,
-    backward: ElectronBrowserViewFunctions.backward,
-    cancelNavigation: ElectronBrowserViewFunctions.cancelNavigation,
-    show: ElectronBrowserViewFunctions.show,
-    hide: ElectronBrowserViewFunctions.hide,
-    inspectElement: ElectronBrowserViewFunctions.inspectElement,
-    copyImageAt: ElectronBrowserViewFunctions.copyImageAt,
-    setFallthroughKeyBindings: ElectronBrowserViewFunctions.setFallthroughKeyBindings,
-    getStats: ElectronBrowserViewFunctions.getStats,
-};

package/src/parts/ElectronBrowserViewFunctions/ElectronBrowserViewFunctions.js

@@ -1,35 +0,0 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js';
-export const resizeBrowserView = (id, x, y, width, height) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.resizeBrowserView', id, x, y, width, height);
-};
-export const setIframeSrc = async (id, iframeSrc) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.setIframeSrc', id, iframeSrc);
-};
-const callFunction = (id, functionName) => {
-    return ParentIpc.invoke('ElectronWebContents.callFunction', id, functionName);
-};
-export const focus = ElectronWebContents.focus;
-export const openDevtools = ElectronWebContents.openDevtools;
-export const reload = ElectronWebContents.reload;
-export const forward = ElectronWebContents.forward;
-export const backward = ElectronWebContents.backward;
-export const cancelNavigation = (id) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.cancelNavigation', id);
-};
-export const show = (id) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.show', id);
-};
-export const hide = (id) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.hide', id);
-};
-export const inspectElement = ElectronWebContents.inspectElement;
-export const copyImageAt = (id, x, y) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.copyImageAt', id, x, y);
-};
-export const setFallthroughKeyBindings = (fallthroughKeyBindings) => {
-    return ParentIpc.invoke('ElectronBrowserViewFunctions.setFallthroughKeyBindings', fallthroughKeyBindings);
-};
-export const getStats = (id) => {
-    return ParentIpc.invoke('ElectronWebContents.getStats', id);
-};

package/src/parts/ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js

@@ -1,15 +0,0 @@
-export const state = {
-    ipcMap: Object.create(null),
-};
-export const add = (id, ipc) => {
-    state.ipcMap[id] = ipc;
-};
-export const get = (id) => {
-    return state.ipcMap[id];
-};
-export const remove = (id) => {
-    delete state.ipcMap[id];
-};
-export const getAll = () => {
-    return Object.values(state.ipcMap);
-};

package/src/parts/ElectronBrowserViewQuickPick/ElectronBrowserViewQuickPick.ipc.js

@@ -1,6 +0,0 @@
-import * as ElectronBrowserViewQuickPick from './ElectronBrowserViewQuickPick.js';
-export const name = 'ElectronBrowserViewQuickPick';
-export const Commands = {
-    startLogging: ElectronBrowserViewQuickPick.createBrowserViewQuickPick,
-    disposeBrowserViewQuickPick: ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick,
-};

package/src/parts/ElectronBrowserViewQuickPick/ElectronBrowserViewQuickPick.js

@@ -1,7 +0,0 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-export const createBrowserViewQuickPick = (x, y, width, height) => {
-    return ParentIpc.invoke('ElectronBrowserViewQuickPick.createBrowserViewQuickPick', x, y, width, height);
-};
-export const disposeBrowserViewQuickPick = () => {
-    return ParentIpc.invoke('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
-};

package/src/parts/ElectronBrowserViewState/ElectronBrowserViewState.js

@@ -1,12 +0,0 @@
-const state = {
-    browserViews: Object.create(null),
-};
-export const add = (id) => {
-    state.browserViews[id] = id;
-};
-export const remove = (id) => {
-    delete state.browserViews[id];
-};
-export const getAll = () => {
-    return Object.values(state.browserViews);
-};

package/src/parts/ElectronBrowserViewSuggestions/ElectronBrowserViewSuggestions.ipc.js

@@ -1,7 +0,0 @@
-import * as ElectronBrowserViewSuggestions from './ElectronBrowserViewSuggestions.js';
-export const name = 'ElectronBrowserViewSuggestions';
-export const Commands = {
-    createBrowserView: ElectronBrowserViewSuggestions.createBrowserView,
-    disposeBrowserView: ElectronBrowserViewSuggestions.disposeBrowserView,
-    setSuggestions: ElectronBrowserViewSuggestions.setSuggestions,
-};

package/src/parts/ElectronBrowserViewSuggestions/ElectronBrowserViewSuggestions.js

@@ -1,10 +0,0 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-export const createBrowserView = (x, y, width, height) => {
-    return ParentIpc.invoke('ElectronBrowserViewSuggestions.createBrowserView', x, y, width, height);
-};
-export const disposeBrowserView = () => {
-    return ParentIpc.invoke('ElectronBrowserViewSuggestions.disposeBrowserView');
-};
-export const setSuggestions = (suggestions) => {
-    return ParentIpc.invoke('ElectronBrowserViewSuggestions.setSuggestions', suggestions);
-};

package/src/parts/ElectronWebContents/ElectronWebContents.ipc.js

@@ -1,12 +0,0 @@
-import * as ElectronWebContents from './ElectronWebContents.js';
-export const name = 'ElectronWebContents';
-export const Commands = {
-    dispose: ElectronWebContents.dispose,
-    handleKeyBinding: ElectronWebContents.handleKeyBinding,
-    handleWindowOpen: ElectronWebContents.handleWindowOpen,
-    handleWillNavigate: ElectronWebContents.handleWillNavigate,
-    handleDidNavigate: ElectronWebContents.handleDidNavigate,
-    handleContextMenu: ElectronWebContents.handleContextMenu,
-    handleTitleUpdated: ElectronWebContents.handleTitleUpdated,
-    handleBrowserViewDestroyed: ElectronWebContents.handleBrowserViewDestroyed, // TODO rename to webcontents
-};

package/src/parts/ElectronWebContents/ElectronWebContents.js

@@ -1,61 +0,0 @@
-import * as ElectronBrowserViewIpcState from '../ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js';
-import * as ElectronBrowserViewState from '../ElectronBrowserViewState/ElectronBrowserViewState.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-export const dispose = async (id) => {
-    await ParentIpc.invoke('ElectronWebContents.dispose', id);
-};
-export const callFunction = (webContentsId, method, ...params) => {
-    return ParentIpc.invoke(`ElectronWebContents.callFunction`, webContentsId, method, ...params);
-};
-export const focus = (webContentsId) => {
-    return callFunction(webContentsId, 'focus');
-};
-export const openDevtools = (webContentsId) => {
-    return callFunction(webContentsId, 'openDevTools');
-};
-export const reload = (webContentsId) => {
-    return callFunction(webContentsId, 'reload');
-};
-export const forward = (webContentsId) => {
-    return callFunction(webContentsId, 'goForward');
-};
-export const backward = (webContentsId) => {
-    return callFunction(webContentsId, 'goBack');
-};
-export const inspectElement = (webContentsId, x, y) => {
-    return callFunction(webContentsId, `inspectElement`, x, y);
-};
-export const handleWindowOpen = (webContentsId, url) => {
-    // TODO
-};
-const forwardEvent = (method, webContentsId, ...params) => {
-    const ipc = ElectronBrowserViewIpcState.get(webContentsId);
-    if (!ipc) {
-        console.log(`[shared-process] no ipc for webcontents ${webContentsId}`);
-        return;
-    }
-    ipc.send({
-        jsonrpc: '2.0',
-        method: `SimpleBrowser.${method}`,
-        params,
-    });
-};
-export const handleWillNavigate = (...args) => {
-    return forwardEvent('handleWillNavigate', ...args);
-};
-export const handleDidNavigate = (...args) => {
-    return forwardEvent('handleDidNavigate', ...args);
-};
-export const handleContextMenu = (...args) => {
-    return forwardEvent('handleContextMenu', ...args);
-};
-export const handleTitleUpdated = (...args) => {
-    return forwardEvent('handleTitleUpdated', ...args);
-};
-export const handleKeyBinding = (...args) => {
-    forwardEvent('handleKeyBinding', ...args);
-};
-export const handleBrowserViewDestroyed = (id) => {
-    ElectronBrowserViewState.remove(id);
-    ElectronBrowserViewIpcState.remove(id);
-};

package/src/parts/ElectronWebContentsView/ElectronWebContentsView.ipc.js

@@ -1,6 +0,0 @@
-import * as ElectronWebContentsView from './ElectronWebContentsView.js';
-export const name = 'ElectronWebContentsView';
-export const Commands = {
-    createWebContentsView: ElectronWebContentsView.createWebContentsView,
-    disposeWebContentsView: ElectronWebContentsView.disposeWebContentsView,
-};

package/src/parts/ElectronWebContentsView/ElectronWebContentsView.js

@@ -1,18 +0,0 @@
-import * as ElectronBrowserViewIpcState from '../ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js';
-import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-import * as Assert from '../Assert/Assert.js';
-export const createWebContentsView = async (ipc, restoreId, fallthroughKeyBindings) => {
-    Assert.object(ipc);
-    Assert.number(restoreId);
-    const webContentsId = await ParentIpc.invoke('ElectronWebContentsView.createWebContentsView', restoreId);
-    ElectronBrowserViewIpcState.add(webContentsId, ipc);
-    // TODO get window id from renderer worker
-    await ParentIpc.invoke('ElectronWebContentsView.attachEventListeners', webContentsId);
-    await ParentIpc.invoke('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white');
-    return webContentsId;
-};
-export const disposeWebContentsView = async (id) => {
-    await ParentIpc.invoke('ElectronWebContentsView.disposeWebContentsView', id);
-    await ElectronWebContents.dispose(id);
-};

package/src/parts/ElectronWebContentsViewFunctions/ElectronWebContentsViewFunctions.ipc.js

@@ -1,18 +0,0 @@
-import * as ElectronWebContentsViewFunctions from './ElectronWebContentsViewFunctions.js';
-export const name = 'ElectronWebContentsViewFunctions';
-export const Commands = {
-    resizeBrowserView: ElectronWebContentsViewFunctions.resizeBrowserView,
-    setIframeSrc: ElectronWebContentsViewFunctions.setIframeSrc,
-    focus: ElectronWebContentsViewFunctions.focus,
-    openDevtools: ElectronWebContentsViewFunctions.openDevtools,
-    reload: ElectronWebContentsViewFunctions.reload,
-    forward: ElectronWebContentsViewFunctions.forward,
-    backward: ElectronWebContentsViewFunctions.backward,
-    cancelNavigation: ElectronWebContentsViewFunctions.cancelNavigation,
-    show: ElectronWebContentsViewFunctions.show,
-    hide: ElectronWebContentsViewFunctions.hide,
-    inspectElement: ElectronWebContentsViewFunctions.inspectElement,
-    copyImageAt: ElectronWebContentsViewFunctions.copyImageAt,
-    setFallthroughKeyBindings: ElectronWebContentsViewFunctions.setFallthroughKeyBindings,
-    getStats: ElectronWebContentsViewFunctions.getStats,
-};

package/src/parts/ElectronWebContentsViewFunctions/ElectronWebContentsViewFunctions.js

@@ -1,35 +0,0 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js';
-export const resizeBrowserView = (id, x, y, width, height) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.resizeBrowserView', id, x, y, width, height);
-};
-export const setIframeSrc = async (id, iframeSrc) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.setIframeSrc', id, iframeSrc);
-};
-const callFunction = (id, functionName) => {
-    return ParentIpc.invoke('ElectronWebContents.callFunction', id, functionName);
-};
-export const focus = ElectronWebContents.focus;
-export const openDevtools = ElectronWebContents.openDevtools;
-export const reload = ElectronWebContents.reload;
-export const forward = ElectronWebContents.forward;
-export const backward = ElectronWebContents.backward;
-export const cancelNavigation = (id) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.cancelNavigation', id);
-};
-export const show = (id) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.show', id);
-};
-export const hide = (id) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.hide', id);
-};
-export const inspectElement = ElectronWebContents.inspectElement;
-export const copyImageAt = (id, x, y) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.copyImageAt', id, x, y);
-};
-export const setFallthroughKeyBindings = (fallthroughKeyBindings) => {
-    return ParentIpc.invoke('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', fallthroughKeyBindings);
-};
-export const getStats = (id) => {
-    return ParentIpc.invoke('ElectronWebContents.getStats', id);
-};