@lvce-editor/shared-process 0.26.4 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.26.4",
+  "version": "0.27.0",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,25 +18,24 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.26.4",
-    "@lvce-editor/ipc": "^8.0.0",
+    "@lvce-editor/extension-host-helper-process": "0.27.0",
+    "@lvce-editor/ipc": "^8.0.1",
     "@lvce-editor/json-rpc": "^1.3.0",
     "@lvce-editor/jsonc-parser": "^1.2.0",
+    "@lvce-editor/network-process": "0.27.0",
     "@lvce-editor/pretty-error": "^1.5.0",
-    "@lvce-editor/pty-host": "0.26.4",
+    "@lvce-editor/pty-host": "0.27.0",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",
     "execa": "^8.0.1",
     "exit-hook": "^4.0.0",
-    "got": "^14.2.1",
     "is-object": "^1.0.2",
-    "p-queue": "^8.0.1",
     "tar-fs": "^3.0.6",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {
-    "@lvce-editor/ripgrep": "^1.0.2",
+    "@lvce-editor/ripgrep": "^1.1.0",
     "open": "^10.1.0",
     "tail": "^2.2.6",
     "tmp-promise": "^3.0.3",

package/src/parts/ConnectIpcToElectron/ConnectIpcToElectron.js

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

package/src/parts/Download/Download.js

@@ -1,24 +1,4 @@
-import got, { RequestError } from 'got';
-import { createWriteStream } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
-import * as Path from '../Path/Path.js';
-import { VError } from '../VError/VError.js';
+import * as NetworkProcess from '../NetworkProcess/NetworkProcess.js';
 export const download = async (url, outFile) => {
-    try {
-        await mkdir(Path.dirname(outFile), { recursive: true });
-        await pipeline(got.stream(url), createWriteStream(outFile));
-    }
-    catch (error) {
-        try {
-            await rm(outFile);
-        }
-        catch {
-            // ignore
-        }
-        if (error instanceof RequestError) {
-            throw new VError(`Failed to download "${url}": ${error.message}`);
-        }
-        throw new VError(error, `Failed to download "${url}"`);
-    }
+    return NetworkProcess.invoke('Download.download', url, outFile);
 };

package/src/parts/DownloadAndExtract/DownloadAndExtract.js

@@ -1,18 +1,4 @@
-import { pipeline } from 'node:stream/promises';
-import { createGunzip } from 'node:zlib';
-import got, { RequestError } from 'got';
-import tar from 'tar-fs';
-import { VError } from '../VError/VError.js';
+import * as NetworkProcess from '../NetworkProcess/NetworkProcess.js';
 export const downloadAndExtractTarGz = async ({ url, outDir, strip }) => {
-    try {
-        await pipeline(got.stream(url), createGunzip(), tar.extract(outDir, {
-            strip,
-        }));
-    }
-    catch (error) {
-        if (error && error instanceof RequestError) {
-            throw new VError(`Failed to download ${url}: ${error.message}`);
-        }
-        throw error;
-    }
+    return NetworkProcess.invoke('Download.downloadAndExtractTarGz', { url, outDir, strip });
 };

package/src/parts/EmbedsProcessState/EmbedsProcessState.js

@@ -0,0 +1,12 @@
+const state = {
+    ref: 0,
+};
+export const increment = () => {
+    state.ref++;
+};
+export const get = () => {
+    return state.ref;
+};
+export const decrement = async () => {
+    state.ref--;
+};

package/src/parts/GetHttpErrorMessage/GetHttpErrorMessage.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {HTTPError} error
+ * @param {any} error
  */
 export const getHttpErrorMessage = (error) => {
     try {

package/src/parts/GetLatestReleaseVersion/GetLatestReleaseVersion.js

@@ -1,5 +1,5 @@
-import got, { HTTPError } from 'got';
 import * as GetHttpErrorMessage from '../GetHttpErrorMessage/GetHttpErrorMessage.js';
+import * as NetworkProcess from '../NetworkProcess/NetworkProcess.js';
 import { VError } from '../VError/VError.js';
 const parseVersionFromUrl = (url, repository) => {
     if (!url.includes('releases/tag')) {
@@ -17,13 +17,16 @@ const parseVersionFromUrl = (url, repository) => {
 };
 export const getLatestReleaseVersion = async (repository) => {
     try {
-        const json = await got.head(`https://github.com/${repository}/releases/latest`);
-        const finalUrl = json.url;
+        const url = `https://github.com/${repository}/releases/latest`;
+        const finalUrl = await NetworkProcess.invoke('Download.getUrl', {
+            method: 'HEAD',
+            url,
+        });
         const version = parseVersionFromUrl(finalUrl, repository);
         return version;
     }
     catch (error) {
-        if (error instanceof HTTPError) {
+        if (error && error.name === 'HTTPError') {
             const httpErrorMessage = GetHttpErrorMessage.getHttpErrorMessage(error);
             throw new VError(`Failed to get latest release for ${repository}: ${httpErrorMessage}`);
         }

package/src/parts/GetPortTuple/GetPortTuple.js

@@ -1,6 +1,12 @@
+import { VError } from '@lvce-editor/verror';
 import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js';
 // workaround for MessageChannelMain not being available in utility process
 export const getPortTuple = async () => {
-    const { port1, port2 } = await TemporaryMessagePort.getPortTuple();
-    return { port1, port2 };
+    try {
+        const { port1, port2 } = await TemporaryMessagePort.getPortTuple();
+        return { port1, port2 };
+    }
+    catch (error) {
+        throw new VError(error, `Failed to get port tuple`);
+    }
 };

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.ipc.js

@@ -2,4 +2,5 @@ import * as HandleMessagePortForEmbedsProcess from './HandleMessagePortForEmbeds
 export const name = 'HandleMessagePortForEmbedsProcess';
 export const Commands = {
     handleMessagePortForEmbedsProcess: HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess,
+    handleEmbedsProcessIpcClosed: HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed,
 };

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.js

@@ -1,7 +1,19 @@
+import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
+import * as EmbedsProcessState from '../EmbedsProcessState/EmbedsProcessState.js';
 import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
 import * as IpcId from '../IpcId/IpcId.js';
 export const handleMessagePortForEmbedsProcess = (port, ipcId) => {
+    EmbedsProcessState.increment();
     return HandleIncomingIpc.handleIncomingIpc(IpcId.EmbedsProcess, port, {
         ipcId,
     });
 };
+export const handleEmbedsProcessIpcClosed = async () => {
+    EmbedsProcessState.decrement();
+    if (EmbedsProcessState.get() === 0) {
+        const promise = EmbedsProcess.state.ipc;
+        EmbedsProcess.state.ipc = undefined;
+        const ipc = await promise;
+        ipc.dispose();
+    }
+};

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -12,7 +12,7 @@ export const create = async (options) => {
     });
     const { port1, port2 } = await GetPortTuple.getPortTuple();
     // TODO use uuid instead of name
-    await TemporaryMessagePort.sendTo(options.name, port2);
+    await TemporaryMessagePort.sendTo(options.name, port2, options.ipcId);
     port1.start();
     return port1;
 };

package/src/parts/LaunchEmbedsProcess/LaunchEmbedsProcess.js

@@ -11,9 +11,9 @@ export const launchEmbedsProcess = async () => {
         argv: [],
         stdio: 'inherit',
         name: 'Embeds Process',
+        ipcId: IpcId.SharedProcess,
     });
     HandleIpc.handleIpc(ipc);
     await ConnectIpcToElectron.connectIpcToElectron(ipc, IpcId.EmbedsProcess);
-    HandleIpc.unhandleIpc(ipc);
     return ipc;
 };

package/src/parts/LaunchNetworkProcess/LaunchNetworkProcess.js

@@ -0,0 +1,15 @@
+import * as NetworkProcessPath from '../NetworkProcessPath/NetworkProcessPath.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const launchNetworkProcess = async () => {
+    const networkProcess = await IpcParent.create({
+        method: IpcParentType.ElectronUtilityProcess,
+        path: NetworkProcessPath.networkProcessPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Network Process',
+    });
+    HandleIpc.handleIpc(networkProcess);
+    return networkProcess;
+};

package/src/parts/LaunchSearchProcess/LaunchSearchProcess.js

@@ -3,13 +3,13 @@ import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
 export const launchSearchProcess = async () => {
-    const embedsProcess = await IpcParent.create({
+    const searchProcess = await IpcParent.create({
         method: IpcParentType.ElectronUtilityProcess,
         path: SearchProcessPath.searchProcessPath,
         argv: [],
         stdio: 'inherit',
         name: 'Search Process',
     });
-    HandleIpc.handleIpc(embedsProcess);
-    return embedsProcess;
+    HandleIpc.handleIpc(searchProcess);
+    return searchProcess;
 };

package/src/parts/ModuleMap/ModuleMap.js

@@ -275,6 +275,7 @@ export const getModuleId = (commandId) => {
         case 'ContentSecurityPolicy.set':
             return ModuleId.ContentSecurityPolicy;
         case 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess':
+        case 'HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed':
             return ModuleId.HandleMessagePortForEmbedsProcess;
         case 'HandleMessagePortForProcessExplorer.handleMessagePortForProcessExplorer':
             return ModuleId.HandleMessagePortForProcessExplorer;

package/src/parts/NetworkProcess/NetworkProcess.js

@@ -0,0 +1,18 @@
+import * as LaunchNetworkProcess from '../LaunchNetworkProcess/LaunchNetworkProcess.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+export const state = {
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+};
+export const getOrCreate = async () => {
+    if (!state.ipc) {
+        state.ipc = LaunchNetworkProcess.launchNetworkProcess();
+    }
+    return state.ipc;
+};
+export const invoke = async (method, ...params) => {
+    const ipc = await getOrCreate();
+    return JsonRpc.invoke(ipc, method, ...params);
+};

package/src/parts/NetworkProcessPath/NetworkProcessPath.js

@@ -0,0 +1 @@
+export { networkProcessPath } from '@lvce-editor/network-process';

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.26.4';
-export const commit = '59e174c';
-export const date = '2024-04-28T08:40:44.000Z';
+export const version = '0.27.0';
+export const commit = 'b9ba170';
+export const date = '2024-04-28T20:59:28.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

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

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -1,8 +0,0 @@
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js';
-import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js';
-export const getFirstNodeWorkerEvent = (worker) => {
-    return GetFirstEvent.getFirstEvent(worker, {
-        exit: FirstNodeWorkerEventType.Exit,
-        error: FirstNodeWorkerEventType.Error,
-    });
-};

package/src/parts/HasPositiveMemoryUsage/HasPositiveMemoryUsage.js

@@ -1,3 +0,0 @@
-export const hasPositiveMemoryUsage = (process) => {
-    return process.memory >= 0;
-};

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -1,53 +0,0 @@
-import { IpcError } from '../IpcError/IpcError.js';
-import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
-export const listen = ({ messagePort }) => {
-    if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
-        throw new IpcError('port must be of type MessagePortMain');
-    }
-    return messagePort;
-};
-const getActualData = (event) => {
-    const { data, ports } = event;
-    if (ports.length === 0) {
-        return data;
-    }
-    return {
-        ...data,
-        params: [...ports, ...data.params],
-    };
-};
-export const wrap = (messagePort) => {
-    return {
-        messagePort,
-        on(event, listener) {
-            if (event === 'message') {
-                const wrappedListener = (event) => {
-                    const actualData = getActualData(event);
-                    listener(actualData);
-                };
-                this.messagePort.on(event, wrappedListener);
-            }
-            else if (event === 'close') {
-                this.messagePort.on('close', listener);
-            }
-            else {
-                throw new Error('unsupported event type');
-            }
-        },
-        off(event, listener) {
-            this.messagePort.off(event, listener);
-        },
-        send(message) {
-            this.messagePort.postMessage(message);
-        },
-        sendAndTransfer(message, transfer) {
-            this.messagePort.postMessage(message, transfer);
-        },
-        dispose() {
-            this.messagePort.close();
-        },
-        start() {
-            this.messagePort.start();
-        },
-    };
-};

package/src/parts/IsDlOpenError/IsDlOpenError.js

@@ -1,4 +0,0 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
-export const isDlOpenError = (error) => {
-    return error && error instanceof Error && 'code' in error && error.code === ErrorCodes.ERR_DLOPEN_FAILED;
-};

package/src/parts/LeftCut/LeftCut.js

@@ -1,19 +0,0 @@
-const RE_WORD = /\b/g;
-export const leftCut = (text, final, charsBefore) => {
-    if (text.length < charsBefore) {
-        return text.length;
-    }
-    let i = 0;
-    while (RE_WORD.test(text)) {
-        if (final - RE_WORD.lastIndex < charsBefore) {
-            break;
-        }
-        i = RE_WORD.lastIndex;
-        RE_WORD.lastIndex++;
-    }
-    RE_WORD.lastIndex = 0;
-    if (final - i > charsBefore + 10) {
-        return final - charsBefore;
-    }
-    return i;
-};

package/src/parts/ParseInt/ParseInt.js

@@ -1,3 +0,0 @@
-export const parseInt = (string) => {
-    return Number.parseInt(string, 10);
-};

package/src/parts/Trace/Trace.js

@@ -1,13 +0,0 @@
-import * as Env from '../Env/Env.js';
-export const LEVEL = {
-    DEFAULT: 1,
-    VERBOSE: 2,
-};
-export const state = {
-    level: LEVEL.VERBOSE,
-};
-export const trace = Env.getNodeEnv() === 'test'
-    ? () => { }
-    : (...args) => {
-        console.info('[Trace]', ...args);
-    };