@lvce-editor/shared-process 0.33.1 → 0.33.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,22 +18,22 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.33.1",
-    "@lvce-editor/ipc": "^9.5.0",
-    "@lvce-editor/json-rpc": "^2.1.0",
+    "@lvce-editor/extension-host-helper-process": "0.33.2",
+    "@lvce-editor/ipc": "^10.0.4",
+    "@lvce-editor/json-rpc": "^3.0.0",
     "@lvce-editor/jsonc-parser": "^1.4.0",
-    "@lvce-editor/pretty-error": "^1.5.0",
+    "@lvce-editor/pretty-error": "^1.6.0",
     "@lvce-editor/verror": "^1.4.0",
     "debug": "^4.3.6",
     "is-object": "^1.0.2",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {
-    "@lvce-editor/network-process": "^1.7.0",
+    "@lvce-editor/network-process": "^2.0.0",
     "@lvce-editor/preload": "^1.4.0",
-    "@lvce-editor/search-process": "^1.4.0",
+    "@lvce-editor/search-process": "^2.0.0",
     "@lvce-editor/typescript-compile-process": "^1.2.0",
-    "@lvce-editor/pty-host": "^1.3.0",
+    "@lvce-editor/pty-host": "^2.0.0",
     "@lvce-editor/embeds-process": "^1.5.0",
     "open": "^10.1.0",
     "tail": "^2.2.6",

package/src/parts/ConnectIpcToElectron/ConnectIpcToElectron.js

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

package/src/parts/FixElectronParameters/FixElectronParameters.js

@@ -0,0 +1,13 @@
+import * as GetTransferrables from '../GetTransferrables/GetTransferrables.js';
+import * as RemoveValues from '../RemoveValues/RemoveValues.js';
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+export const fixElectronParameters = (value) => {
+    const transfer = GetTransferrables.getTransferrables(value);
+    const newValue = RemoveValues.removeValues(value, transfer);
+    return {
+        newValue,
+        transfer,
+    };
+};

package/src/parts/GetTransferrables/GetTransferrables.js

@@ -0,0 +1,7 @@
+import * as WalkValue from '../WalkValue/WalkValue.js';
+import * as IsTransferrable from '../IsTransferrable/IsTransferrable.js';
+export const getTransferrables = (value) => {
+    const transferrables = [];
+    WalkValue.walkValue(value, transferrables, IsTransferrable.isTransferrable);
+    return transferrables;
+};

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -1,6 +1,8 @@
 import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
 import * as IpcId from '../IpcId/IpcId.js';
+import * as Assert from '../Assert/Assert.js';
 export const handleElectronMessagePort = (messagePort, ipcId) => {
+    Assert.object(messagePort);
     const message = {
         ipcId,
     };

package/src/parts/HandleIncomingIpc/HandleIncomingIpc.js

@@ -4,11 +4,15 @@ import * as HandleIncomingIpcMessagePort from '../HandleIncomingIpcMessagePort/H
 import * as HandleIncomingIpcWebSocket from '../HandleIncomingIpcWebSocket/HandleIncomingIpcWebSocket.js';
 import * as HandleIpcModule from '../HandleIpcModule/HandleIpcModule.js';
 import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
+import * as IsSocket from '../IsSocket/IsSocket.js';
 const getIpcAndResponse = (module, handle, message) => {
     if (IsMessagePortMain.isMessagePortMain(handle)) {
         return HandleIncomingIpcMessagePort.handleIncomingIpcMessagePort(module, handle, message);
     }
-    return HandleIncomingIpcWebSocket.handleIncomingIpcWebSocket(module, handle, message);
+    if (IsSocket.isSocket(handle)) {
+        return HandleIncomingIpcWebSocket.handleIncomingIpcWebSocket(module, handle, message);
+    }
+    throw new Error(`Unexpected ipc handle`);
 };
 export const handleIncomingIpc = async (ipcId, handle, message) => {
     Assert.number(ipcId);

package/src/parts/HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js

@@ -6,7 +6,6 @@ export const upgradeMessagePort = (port, message) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [message.ipcId],
-        transfer: [port],
+        params: [port, message.ipcId],
     };
 };

package/src/parts/HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js

@@ -24,7 +24,6 @@ export const upgradeMessagePort = (port) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [],
-        transfer: [port],
+        params: [port],
     };
 };

package/src/parts/HandleIpcFileWatcher/HandleIpcFileWatcher.js

@@ -18,7 +18,6 @@ export const upgradeMessagePort = (port) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [],
-        transfer: [port],
+        params: [port],
     };
 };

package/src/parts/HandleIpcProcessExplorer/HandleIpcProcessExplorer.js

@@ -8,7 +8,6 @@ export const upgradeMessagePort = (port) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [],
-        transfer: [port],
+        params: [port],
     };
 };

package/src/parts/HandleIpcSearchProcess/HandleIpcSearchProcess.js

@@ -17,7 +17,6 @@ export const upgradeMessagePort = (port) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [],
-        transfer: [port],
+        params: [port],
     };
 };

package/src/parts/HandleIpcTerminalProcess/HandleIpcTerminalProcess.js

@@ -18,7 +18,6 @@ export const upgradeMessagePort = (port) => {
     return {
         type: 'send',
         method: 'HandleElectronMessagePort.handleElectronMessagePort',
-        params: [],
-        transfer: [port],
+        params: [port],
     };
 };

package/src/parts/HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.js

@@ -1,5 +1,8 @@
+import * as Assert from '../Assert/Assert.js';
 import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
 import * as IpcId from '../IpcId/IpcId.js';
 export const handleMessagePortForProcessExplorer = (port) => {
+    Assert.object(port);
+    console.log('got port', port);
     return HandleIncomingIpc.handleIncomingIpc(IpcId.ProcessExplorer, port, {});
 };

package/src/parts/HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.js

@@ -1,5 +1,7 @@
 import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
 import * as IpcId from '../IpcId/IpcId.js';
+import * as Assert from '../Assert/Assert.js';
 export const handleMessagePortForTerminalProcess = (port) => {
+    Assert.object(port);
     return HandleIncomingIpc.handleIncomingIpc(IpcId.TerminalProcess, port, {});
 };

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -1,3 +1,4 @@
+import * as FixElectronParameters from '../FixElectronParameters/FixElectronParameters.js';
 import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
 import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js';
@@ -19,6 +20,16 @@ export const create = async (options) => {
 export const signal = (port) => {
     port.start();
 };
+const getActualData = (event) => {
+    const { data, ports } = event;
+    if (ports.length > 0) {
+        return {
+            ...data,
+            params: [...ports, ...data.params],
+        };
+    }
+    return data;
+};
 export const wrap = (port) => {
     return {
         port,
@@ -26,8 +37,9 @@ export const wrap = (port) => {
         send(message) {
             this.port.postMessage(message);
         },
-        async sendAndTransfer(message, transfer) {
-            this.port.postMessage(message, transfer);
+        async sendAndTransfer(message) {
+            const { newValue, transfer } = FixElectronParameters.fixElectronParameters(message);
+            this.port.postMessage(newValue, transfer);
         },
         on(event, listener) {
             switch (event) {
@@ -38,7 +50,7 @@ export const wrap = (port) => {
                     // @ts-ignore
                     this.wrappedListener = (event) => {
                         const syntheticEvent = {
-                            data: event.data,
+                            data: getActualData(event),
                             target: this,
                         };
                         listener(syntheticEvent);

package/src/parts/IsSocket/IsSocket.js

@@ -0,0 +1,4 @@
+import { Socket } from 'node:net';
+export const isSocket = (value) => {
+    return value instanceof Socket;
+};

package/src/parts/IsTransferrable/IsTransferrable.js

@@ -0,0 +1,9 @@
+import * as Transferrables from '../Transferrables/Transferrables.js';
+export const isTransferrable = (value) => {
+    for (const fn of Transferrables.transferrables) {
+        if (fn(value)) {
+            return true;
+        }
+    }
+    return false;
+};

package/src/parts/LaunchProcessExplorer/LaunchProcessExplorer.js

@@ -5,6 +5,7 @@ import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
 import * as ProcessExplorerPath from '../ProcessExplorerPath/ProcessExplorerPath.js';
 export const launchProcessExplorer = async () => {
+    console.log('will start process explorer');
     const ipc = await IpcParent.create({
         method: IpcParentType.ElectronUtilityProcess,
         path: ProcessExplorerPath.processExplorerPath,
@@ -15,5 +16,6 @@ export const launchProcessExplorer = async () => {
     HandleIpc.handleIpc(ipc);
     await ConnectIpcToElectron.connectIpcToElectron(ipc, IpcId.ProcessExplorerRenderer);
     HandleIpc.unhandleIpc(ipc);
+    console.log('did start process explorer');
     return ipc;
 };

package/src/parts/Main/Main.js

@@ -6,6 +6,7 @@ import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js';
 import * as Signal from '../Signal/Signal.js';
 export const main = async () => {
+    Error.stackTraceLimit = 999;
     Command.setLoad(Module.load);
     process.on('disconnect', HandleDisconnect.handleDisconnect);
     process.on(Signal.SIGTERM, ProcessListeners.handleSigTerm);

package/src/parts/ParentIpc/ParentIpc.js

@@ -22,6 +22,6 @@ export const listen = async () => {
 export const invoke = (method, ...params) => {
     return JsonRpc.invoke(state.ipc, method, ...params);
 };
-export const invokeAndTransfer = (method, transfer, ...params) => {
-    return JsonRpc.invokeAndTransfer(state.ipc, transfer, method, ...params);
+export const invokeAndTransfer = (method, ...params) => {
+    return JsonRpc.invokeAndTransfer(state.ipc, method, ...params);
 };

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.33.1';
-export const commit = '2aa17eb';
-export const date = '2024-08-24T19:49:47.000Z';
+export const version = '0.33.2';
+export const commit = 'fa60d57';
+export const date = '2024-08-25T16:12:04.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/RemoveValues/RemoveValues.js

@@ -0,0 +1,24 @@
+export const removeValues = (value, toRemove) => {
+    if (!value) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const newItems = [];
+        for (const item of value) {
+            if (!toRemove.includes(item)) {
+                newItems.push(removeValues(item, toRemove));
+            }
+        }
+        return newItems;
+    }
+    if (typeof value === 'object') {
+        const newObject = Object.create(null);
+        for (const [key, property] of Object.entries(value)) {
+            if (!toRemove.includes(property)) {
+                newObject[key] = removeValues(property, toRemove);
+            }
+        }
+        return newObject;
+    }
+    return value;
+};

package/src/parts/SendIncomingIpc/SendIncomingIpc.js

@@ -38,7 +38,7 @@ export const sendIncomingIpc = async (target, response, ipcId) => {
         HandleIpc.handleIpc(target);
     }
     addState(ipcId);
-    await JsonRpc.invokeAndTransfer(target, response.transfer, response.method, ...response.params);
+    await JsonRpc.invokeAndTransfer(target, response.method, ...response.params);
     removeState(ipcId);
     if (!hasState(ipcId) && supportsPartialIpcHandling(ipcId)) {
         HandleIpc.unhandleIpc(target);

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -20,7 +20,7 @@ export const getPortTuple = async () => {
 export const sendTo = async (name, port, ipcId) => {
     Assert.string(name);
     Assert.object(port);
-    await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', [port], name, ipcId);
+    await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', port, name, ipcId);
 };
 export const handlePorts = (port1, port2, id1, id2) => {
     Assert.number(id1);

package/src/parts/Transferrables/Transferrables.js

@@ -0,0 +1,4 @@
+import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js';
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
+import * as IsSocket from '../IsSocket/IsSocket.js';
+export const transferrables = [IsMessagePort.isMessagePort, IsMessagePortMain.isMessagePortMain, IsSocket.isSocket];

package/src/parts/WalkValue/WalkValue.js

@@ -0,0 +1,21 @@
+export const walkValue = (value, transferrables, isTransferrable) => {
+    if (!value) {
+        return;
+    }
+    if (isTransferrable(value)) {
+        transferrables.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            walkValue(item, transferrables, isTransferrable);
+        }
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const property of Object.values(value)) {
+            walkValue(property, transferrables, isTransferrable);
+        }
+        return;
+    }
+};