@lvce-editor/shared-process 0.25.10 → 0.25.12

package/src/parts/RebuildForElectron/RebuildForElectron.js

@@ -1,18 +1,18 @@
-import { VError } from '@lvce-editor/verror'
-import * as Exec from '../Exec/Exec.js'
-import * as GetElectronRebuildPath from '../GetElectronRebuildPath/GetElectronRebuildPath.js'
-
+import { VError } from '@lvce-editor/verror';
+import * as Exec from '../Exec/Exec.js';
+import * as GetElectronRebuildPath from '../GetElectronRebuildPath/GetElectronRebuildPath.js';
 /**
  * @param {string} cwd
  */
 export const rebuild = async (cwd) => {
-  try {
-    const electronRebuildPath = GetElectronRebuildPath.getElectronRebuildPath()
-    await Exec.exec(electronRebuildPath, [], {
-      cwd,
-      stdio: 'inherit',
-    })
-  } catch (error) {
-    throw new VError(error, `Failed to rebuild native module`)
-  }
-}
+    try {
+        const electronRebuildPath = GetElectronRebuildPath.getElectronRebuildPath();
+        await Exec.exec(electronRebuildPath, [], {
+            cwd,
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to rebuild native module`);
+    }
+};

package/src/parts/RebuildForNode/RebuildForNode.js

@@ -1,16 +1,16 @@
-import { VError } from '@lvce-editor/verror'
-import * as Exec from '../Exec/Exec.js'
-
+import { VError } from '@lvce-editor/verror';
+import * as Exec from '../Exec/Exec.js';
 /**
  * @param {string} cwd
  */
 export const rebuild = async (cwd) => {
-  try {
-    await Exec.exec('npm', ['rebuild'], {
-      cwd,
-      stdio: 'inherit',
-    })
-  } catch (error) {
-    throw new VError(error, `Failed to rebuild native module`)
-  }
-}
+    try {
+        await Exec.exec('npm', ['rebuild'], {
+            cwd,
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to rebuild native module`);
+    }
+};

package/src/parts/RebuildNodePty/RebuildNodePty.ipc.js

@@ -1,7 +1,5 @@
-import * as RebuildNodePty from './RebuildNodePty.js'
-
-export const name = 'RebuildNodePty'
-
+import * as RebuildNodePty from './RebuildNodePty.js';
+export const name = 'RebuildNodePty';
 export const Commands = {
-  rebuildNodePty: RebuildNodePty.rebuildNodePty,
-}
+    rebuildNodePty: RebuildNodePty.rebuildNodePty,
+};

package/src/parts/RebuildNodePty/RebuildNodePty.js

@@ -1,25 +1,23 @@
-import * as IsElectron from '../IsElectron/IsElectron.js'
-import * as Path from '../Path/Path.js'
-import * as Root from '../Root/Root.js'
-import { VError } from '../VError/VError.js'
-
+import * as IsElectron from '../IsElectron/IsElectron.js';
+import * as Path from '../Path/Path.js';
+import * as Root from '../Root/Root.js';
+import { VError } from '../VError/VError.js';
 const getPtyHostPath = () => {
-  return Path.join(Root.root, 'packages', 'pty-host')
-}
-
+    return Path.join(Root.root, 'packages', 'pty-host');
+};
 const getModule = () => {
-  if (IsElectron.isElectron()) {
-    return import('../RebuildForElectron/RebuildForElectron.js')
-  }
-  return import('../RebuildForNode/RebuildForNode.js')
-}
-
+    if (IsElectron.isElectron()) {
+        return import('../RebuildForElectron/RebuildForElectron.js');
+    }
+    return import('../RebuildForNode/RebuildForNode.js');
+};
 export const rebuildNodePty = async () => {
-  try {
-    const ptyHostPath = getPtyHostPath()
-    const module = await getModule()
-    await module.rebuild(ptyHostPath)
-  } catch (error) {
-    throw new VError(error, `Failed to rebuild node-pty`)
-  }
-}
+    try {
+        const ptyHostPath = getPtyHostPath();
+        const module = await getModule();
+        await module.rebuild(ptyHostPath);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to rebuild node-pty`);
+    }
+};

package/src/parts/RecentlyOpened/RecentlyOpened.ipc.js

@@ -1,7 +1,5 @@
-import * as RecentlyOpened from './RecentlyOpened.js'
-
-export const name = 'RecentlyOpened'
-
+import * as RecentlyOpened from './RecentlyOpened.js';
+export const name = 'RecentlyOpened';
 export const Commands = {
-  addPath: RecentlyOpened.addPath,
-}
+    addPath: RecentlyOpened.addPath,
+};

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -1,59 +1,60 @@
-import { dirname } from 'node:path'
-import * as Assert from '../Assert/Assert.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as Json from '../Json/Json.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import { dirname } from 'node:path';
+import * as Assert from '../Assert/Assert.js';
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as Json from '../Json/Json.js';
+import * as JsonFile from '../JsonFile/JsonFile.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 const addToArrayUnique = (recentlyOpened, path) => {
-  const index = recentlyOpened.indexOf(path)
-  if (index === -1) {
-    return [path, ...recentlyOpened]
-  }
-  return [path, ...recentlyOpened.slice(0, index), ...recentlyOpened.slice(index + 1)]
-}
-
+    const index = recentlyOpened.indexOf(path);
+    if (index === -1) {
+        return [path, ...recentlyOpened];
+    }
+    return [path, ...recentlyOpened.slice(0, index), ...recentlyOpened.slice(index + 1)];
+};
 const getRecentlyOpened = async (recentlyOpenedPath) => {
-  try {
-    const parsed = await JsonFile.readJson(recentlyOpenedPath)
-    return parsed
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      // ignore
-    } else if (error && error.code === ErrorCodes.E_JSON_PARSE) {
-      // ignore
-    } else {
-      throw new VError(error, `Failed to read recently opened`)
+    try {
+        const parsed = await JsonFile.readJson(recentlyOpenedPath);
+        return parsed;
+    }
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            // ignore
+        }
+        else if (error && error.code === ErrorCodes.E_JSON_PARSE) {
+            // ignore
+        }
+        else {
+            throw new VError(error, `Failed to read recently opened`);
+        }
+        return [];
     }
-    return []
-  }
-}
-
+};
 const setRecentlyOpened = async (recentlyOpenedPath, newRecentlyOpened) => {
-  const stringified = Json.stringify(newRecentlyOpened)
-  try {
-    await FileSystem.writeFile(recentlyOpenedPath, stringified)
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      await FileSystem.mkdir(dirname(recentlyOpenedPath))
-      await FileSystem.writeFile(recentlyOpenedPath, stringified)
-      return
+    const stringified = Json.stringify(newRecentlyOpened);
+    try {
+        await FileSystem.writeFile(recentlyOpenedPath, stringified);
+    }
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            await FileSystem.mkdir(dirname(recentlyOpenedPath));
+            await FileSystem.writeFile(recentlyOpenedPath, stringified);
+            return;
+        }
+        throw error;
     }
-    throw error
-  }
-}
-
+};
 export const addPath = async (path) => {
-  try {
-    Assert.string(path)
-    const recentlyOpenedPath = PlatformPaths.getRecentlyOpenedPath()
-    const parsed = await getRecentlyOpened(recentlyOpenedPath)
-    const newRecentlyOpened = addToArrayUnique(parsed, path)
-    await setRecentlyOpened(recentlyOpenedPath, newRecentlyOpened)
-  } catch (error) {
-    throw new VError(error, `Failed to add path to recently opened`)
-  }
-}
+    try {
+        Assert.string(path);
+        const recentlyOpenedPath = PlatformPaths.getRecentlyOpenedPath();
+        const parsed = await getRecentlyOpened(recentlyOpenedPath);
+        const newRecentlyOpened = addToArrayUnique(parsed, path);
+        await setRecentlyOpened(recentlyOpenedPath, newRecentlyOpened);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to add path to recently opened`);
+    }
+};

package/src/parts/RemoveSymlink/RemoveSymlink.js

@@ -1,12 +1,12 @@
-import { rm } from 'node:fs/promises'
-import * as Assert from '../Assert/Assert.js'
-import { VError } from '../VError/VError.js'
-
+import { rm } from 'node:fs/promises';
+import * as Assert from '../Assert/Assert.js';
+import { VError } from '../VError/VError.js';
 export const removeSymlink = async (path) => {
-  try {
-    Assert.string(path)
-    await rm(path, { force: true })
-  } catch (error) {
-    throw new VError(error, `Failed to remove symlink ${path}`)
-  }
-}
+    try {
+        Assert.string(path);
+        await rm(path, { force: true });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to remove symlink ${path}`);
+    }
+};

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -2,19 +2,18 @@
 // most commands don't require sockets
 // but output channel and terminal need to continuously send data through the socket
 const METHODS_THAT_REQUIRE_SOCKET = new Set([
-  'OutputChannel.open',
-  'ExtensionHost.start',
-  'ExtensionHost.send',
-  'ExtensionHost.watchColorTheme',
-  'Terminal.create',
-  'IncrementalTextSearch.start',
-  'ElectronApplicationMenu.setItems',
-  'GetWindowId.getWindowId',
-  'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess',
-  'ElectronBrowserView.createBrowserView',
-  'ElectronWebContentsView.createWebContentsView',
-])
-
+    'OutputChannel.open',
+    'ExtensionHost.start',
+    'ExtensionHost.send',
+    'ExtensionHost.watchColorTheme',
+    'Terminal.create',
+    'IncrementalTextSearch.start',
+    'ElectronApplicationMenu.setItems',
+    'GetWindowId.getWindowId',
+    'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess',
+    'ElectronBrowserView.createBrowserView',
+    'ElectronWebContentsView.createWebContentsView',
+]);
 export const requiresSocket = (method) => {
-  return METHODS_THAT_REQUIRE_SOCKET.has(method)
-}
+    return METHODS_THAT_REQUIRE_SOCKET.has(method);
+};

package/src/parts/Restart/Restart.js

@@ -1,11 +1,10 @@
-import { spawn } from 'node:child_process'
-
+import { spawn } from 'node:child_process';
 export const restart = (downloadPath) => {
-  const { ELECTRON_RUN_AS_NODE, ...env } = process.env
-  // TODO handle errors
-  const childProcess = spawn(downloadPath, {
-    stdio: 'inherit',
-    env,
-  })
-  childProcess.unref()
-}
+    const { ELECTRON_RUN_AS_NODE, ...env } = process.env;
+    // TODO handle errors
+    const childProcess = spawn(downloadPath, {
+        stdio: 'inherit',
+        env,
+    });
+    childProcess.unref();
+};

package/src/parts/RipGrep/RipGrep.js

@@ -1,40 +1,38 @@
-import * as NodeChildProcess from 'node:child_process'
-import * as Assert from '../Assert/Assert.js'
-import * as Env from '../Env/Env.js'
-import * as Exec from '../Exec/Exec.js'
-import * as RgPath from '../RipGrepPath/RipGrepPath.js'
-import { VError } from '../VError/VError.js'
-
-export const ripGrepPath = Env.getRipGrepPath() || RgPath.rgPath
-
+import * as NodeChildProcess from 'node:child_process';
+import * as Assert from '../Assert/Assert.js';
+import * as Env from '../Env/Env.js';
+import * as Exec from '../Exec/Exec.js';
+import * as RgPath from '../RipGrepPath/RipGrepPath.js';
+import { VError } from '../VError/VError.js';
+export const ripGrepPath = Env.getRipGrepPath() || RgPath.rgPath;
 export const spawn = (args, options) => {
-  try {
-    const childProcess = NodeChildProcess.spawn(RgPath.rgPath, args, options)
-    return {
-      childProcess,
-      on(event, listener) {
-        this.childProcess.on(event, listener)
-      },
-      off(event, listener) {
-        this.childProcess.off(event, listener)
-      },
-      once(event, listener) {
-        this.childProcess.once(event, listener)
-      },
-      stdout: childProcess.stdout,
-      stderr: childProcess.stderr,
-      kill() {
-        this.childProcess.kill()
-      },
+    try {
+        const childProcess = NodeChildProcess.spawn(RgPath.rgPath, args, options);
+        return {
+            childProcess,
+            on(event, listener) {
+                this.childProcess.on(event, listener);
+            },
+            off(event, listener) {
+                this.childProcess.off(event, listener);
+            },
+            once(event, listener) {
+                this.childProcess.once(event, listener);
+            },
+            stdout: childProcess.stdout,
+            stderr: childProcess.stderr,
+            kill() {
+                this.childProcess.kill();
+            },
+        };
     }
-  } catch (error) {
-    throw new VError(error, `Failed to spawn ripgrep`)
-  }
-}
-
+    catch (error) {
+        throw new VError(error, `Failed to spawn ripgrep`);
+    }
+};
 export const exec = async (args, options) => {
-  Assert.array(args)
-  Assert.object(options)
-  const { stdout, stderr } = await Exec.exec(ripGrepPath, args, options)
-  return { stdout, stderr }
-}
+    Assert.array(args);
+    Assert.object(options);
+    const { stdout, stderr } = await Exec.exec(ripGrepPath, args, options);
+    return { stdout, stderr };
+};

package/src/parts/RipGrepParsedLineType/RipGrepParsedLineType.js

@@ -1,4 +1,4 @@
-export const Begin = 'begin'
-export const Match = 'match'
-export const Summary = 'summary'
-export const Context = 'context'
+export const Begin = 'begin';
+export const Match = 'match';
+export const Summary = 'summary';
+export const Context = 'context';

package/src/parts/RipGrepPath/RipGrepPath.js

@@ -1 +1 @@
-export { rgPath } from '@lvce-editor/ripgrep'
+export { rgPath } from '@lvce-editor/ripgrep';

package/src/parts/Root/Root.js

@@ -1,6 +1,4 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export const root = resolve(__dirname, '../../../')
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const root = resolve(__dirname, '../../../');

package/src/parts/Screen/Screen.ipc.js

@@ -1,9 +1,7 @@
-import * as Screen from './Screen.js'
-
-export const name = 'Screen'
-
+import * as Screen from './Screen.js';
+export const name = 'Screen';
 export const Commands = {
-  getBounds: Screen.getBounds,
-  getWidth: Screen.getWidth,
-  getHeight: Screen.getHeight,
-}
+    getBounds: Screen.getBounds,
+    getWidth: Screen.getWidth,
+    getHeight: Screen.getHeight,
+};

package/src/parts/Screen/Screen.js

@@ -1,13 +1,10 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js'
-
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 export const getWidth = () => {
-  return ParentIpc.invoke('ElectronScreen.getWidth')
-}
-
+    return ParentIpc.invoke('ElectronScreen.getWidth');
+};
 export const getHeight = () => {
-  return ParentIpc.invoke('ElectronScreen.getHeight')
-}
-
+    return ParentIpc.invoke('ElectronScreen.getHeight');
+};
 export const getBounds = () => {
-  return ParentIpc.invoke('ElectronScreen.getBounds')
-}
+    return ParentIpc.invoke('ElectronScreen.getBounds');
+};

package/src/parts/SearchFile/SearchFile.ipc.js

@@ -1,7 +1,5 @@
-import * as SearchFile from './SearchFile.js'
-
-export const name = 'SearchFile'
-
+import * as SearchFile from './SearchFile.js';
+export const name = 'SearchFile';
 export const Commands = {
-  searchFile: SearchFile.searchFile,
-}
+    searchFile: SearchFile.searchFile,
+};

package/src/parts/SearchFile/SearchFile.js

@@ -1,35 +1,34 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Character from '../Character/Character.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as LimitString from '../LimitString/LimitString.js'
-import * as Logger from '../Logger/Logger.js'
-import * as RipGrep from '../RipGrep/RipGrep.js'
-
+import * as Assert from '../Assert/Assert.js';
+import * as Character from '../Character/Character.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as LimitString from '../LimitString/LimitString.js';
+import * as Logger from '../Logger/Logger.js';
+import * as RipGrep from '../RipGrep/RipGrep.js';
 // TODO don't necessarily need ripgrep to list all the files,
 // maybe also a faster c program can do it
 // another option would be to cache the results in renderer-worker and
 // do a delta comparison, so the first time it would send 100kB
 // but the second time only a few hundred bytes of changes
-
 export const searchFile = async ({ searchPath = '', limit = 100, ripGrepArgs = [] }) => {
-  try {
-    Assert.string(searchPath)
-    Assert.array(ripGrepArgs)
-    Assert.number(limit)
-    const { stdout, stderr } = await RipGrep.exec(ripGrepArgs, {
-      cwd: searchPath,
-    })
-    return LimitString.limitString(stdout, limit)
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      Logger.info(`[shared-process] ripgrep could not be found at "${RipGrep.ripGrepPath}"`)
-      return Character.EmptyString
+    try {
+        Assert.string(searchPath);
+        Assert.array(ripGrepArgs);
+        Assert.number(limit);
+        const { stdout, stderr } = await RipGrep.exec(ripGrepArgs, {
+            cwd: searchPath,
+        });
+        return LimitString.limitString(stdout, limit);
     }
-    // @ts-ignore
-    if (error && error.stderr === Character.EmptyString) {
-      return Character.EmptyString
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            Logger.info(`[shared-process] ripgrep could not be found at "${RipGrep.ripGrepPath}"`);
+            return Character.EmptyString;
+        }
+        // @ts-ignore
+        if (error && error.stderr === Character.EmptyString) {
+            return Character.EmptyString;
+        }
+        Logger.error(error);
+        return Character.EmptyString;
     }
-    Logger.error(error)
-    return Character.EmptyString
-  }
-}
+};

package/src/parts/SetHeaders/SetHeaders.js

@@ -1,5 +1,5 @@
 export const setHeaders = (response, headers) => {
-  for (const [key, value] of Object.entries(headers)) {
-    response.setHeader(key, value)
-  }
-}
+    for (const [key, value] of Object.entries(headers)) {
+        response.setHeader(key, value);
+    }
+};

package/src/parts/ShouldLogError/ShouldLogError.js

@@ -1,8 +1,7 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
 export const shouldLogError = (error) => {
-  if (error && error.code === ErrorCodes.ENOENT) {
-    return false
-  }
-  return true
-}
+    if (error && error.code === ErrorCodes.ENOENT) {
+        return false;
+    }
+    return true;
+};

package/src/parts/ShouldTranspileTypescript/ShouldTranspileTypescript.js

@@ -1,12 +1,11 @@
-import * as IsTypeScriptPath from '../IsTypeScriptPath/IsTypeScriptPath.js'
-
+import * as IsTypeScriptPath from '../IsTypeScriptPath/IsTypeScriptPath.js';
 export const shouldTranspileTypescript = (request, url) => {
-  if (!IsTypeScriptPath.isTypeScriptPath(url)) {
-    return false
-  }
-  const acceptHeader = request.headers['accept']
-  if (acceptHeader === 'text/plain') {
-    return false
-  }
-  return true
-}
+    if (!IsTypeScriptPath.isTypeScriptPath(url)) {
+        return false;
+    }
+    const acceptHeader = request.headers['accept'];
+    if (acceptHeader === 'text/plain') {
+        return false;
+    }
+    return true;
+};

package/src/parts/Signal/Signal.js

@@ -1,3 +1,3 @@
-export const SIGUSR1 = 'SIGUSR1'
-export const SIGTERM = 'SIGTERM'
-export const SIGINT = 'SIGINT'
+export const SIGUSR1 = 'SIGUSR1';
+export const SIGTERM = 'SIGTERM';
+export const SIGINT = 'SIGINT';

package/src/parts/SplitLines/SplitLines.js

@@ -1,5 +1,4 @@
-import * as Character from '../Character/Character.js'
-
+import * as Character from '../Character/Character.js';
 export const splitLines = (lines) => {
-  return lines.split(Character.NewLine)
-}
+    return lines.split(Character.NewLine);
+};

package/src/parts/SymLink/SymLink.js

@@ -1,5 +1,4 @@
-import symlinkDir from 'symlink-dir'
-
+import symlinkDir from 'symlink-dir';
 export const createSymLink = async (target, path) => {
-  await symlinkDir(target, path)
-}
+    await symlinkDir(target, path);
+};

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

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