@lvce-editor/shared-process 0.25.10 → 0.25.11

package/src/parts/ClipBoard/ClipBoardGnome.js

@@ -1,62 +1,57 @@
 // see https://www.cyberciti.biz/faq/how-do-i-copy-a-file-to-the-clipboard-in-linux
 // see also http://manpages.ubuntu.com/manpages/bionic/man1/xclip.1.html
 // on gnome, get current selection targets with `xclip -selection clipboard -t TARGETS -o`
-
-import * as Exec from '../Exec/Exec.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-import { VError } from '../VError/VError.js'
-
+import * as Exec from '../Exec/Exec.js';
+import * as JoinLines from '../JoinLines/JoinLines.js';
+import * as SplitLines from '../SplitLines/SplitLines.js';
+import { VError } from '../VError/VError.js';
 const removePrefix = (file) => {
-  if (file.startsWith('file://')) {
-    return file.slice('file://'.length)
-  }
-  return file
-}
-
+    if (file.startsWith('file://')) {
+        return file.slice('file://'.length);
+    }
+    return file;
+};
 const addPrefix = (file) => {
-  return `file://${file}`
-}
-
+    return `file://${file}`;
+};
 export const readFiles = async () => {
-  let result
-  try {
-    result = await Exec.exec('xclip', ['-selection', 'clipboard', '-o', '-t', 'x-special/gnome-copied-files'], {})
-  } catch (error) {
-    if (
-      error &&
-      // @ts-ignore
-      error.stderr === 'Error: target x-special/gnome-copied-files not available'
-    ) {
-      return
+    let result;
+    try {
+        result = await Exec.exec('xclip', ['-selection', 'clipboard', '-o', '-t', 'x-special/gnome-copied-files'], {});
+    }
+    catch (error) {
+        if (error &&
+            // @ts-ignore
+            error.stderr === 'Error: target x-special/gnome-copied-files not available') {
+            return;
+        }
+        throw error;
     }
-    throw error
-  }
-  const [type, ...files] = SplitLines.splitLines(result.stdout)
-  const actualFiles = files.map(removePrefix)
-  return {
-    source: 'gnomeCopiedFiles',
-    type,
-    files: actualFiles,
-  }
-}
-
+    const [type, ...files] = SplitLines.splitLines(result.stdout);
+    const actualFiles = files.map(removePrefix);
+    return {
+        source: 'gnomeCopiedFiles',
+        type,
+        files: actualFiles,
+    };
+};
 export const writeFiles = async (type, files) => {
-  const filesWithPrefix = files.map(addPrefix)
-  const gnomeCopiedFilesContent = JoinLines.joinLines([type, ...filesWithPrefix])
-  const uriListContent = JoinLines.joinLines(filesWithPrefix)
-  const plainContent = JoinLines.joinLines(files)
-  try {
-    await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'x-special/gnome-copied-files'], {
-      input: gnomeCopiedFilesContent,
-    })
-    await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'text/uri-list'], {
-      input: uriListContent,
-    })
-    await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'text/plain'], {
-      input: plainContent,
-    })
-  } catch (error) {
-    throw new VError(error, 'Failed to copy files to clipboard')
-  }
-}
+    const filesWithPrefix = files.map(addPrefix);
+    const gnomeCopiedFilesContent = JoinLines.joinLines([type, ...filesWithPrefix]);
+    const uriListContent = JoinLines.joinLines(filesWithPrefix);
+    const plainContent = JoinLines.joinLines(files);
+    try {
+        await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'x-special/gnome-copied-files'], {
+            input: gnomeCopiedFilesContent,
+        });
+        await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'text/uri-list'], {
+            input: uriListContent,
+        });
+        await Exec.exec('xclip', ['-i', '-selection', 'clipboard', '-t', 'text/plain'], {
+            input: plainContent,
+        });
+    }
+    catch (error) {
+        throw new VError(error, 'Failed to copy files to clipboard');
+    }
+};

package/src/parts/ClipBoard/ClipBoardNoop.js

@@ -1,14 +1,12 @@
-import * as Desktop from '../Desktop/Desktop.js'
-
+import * as Desktop from '../Desktop/Desktop.js';
 export const readFiles = async () => {
-  return {
-    source: 'notSupported',
-    type: 'none',
-    files: [],
-  }
-}
-
+    return {
+        source: 'notSupported',
+        type: 'none',
+        files: [],
+    };
+};
 export const writeFiles = (type, files) => {
-  const desktop = Desktop.getDesktop()
-  console.info(`writing files to clipboard is not yet supported on ${desktop}`)
-}
+    const desktop = Desktop.getDesktop();
+    console.info(`writing files to clipboard is not yet supported on ${desktop}`);
+};

package/src/parts/ClipBoard/ClipBoardWindows.js

@@ -1,21 +1,20 @@
 // @ts-ignore
-import clipboardEx from 'electron-clipboard-ex'
-import { VError } from '../VError/VError.js'
-
+import clipboardEx from 'electron-clipboard-ex';
+import { VError } from '../VError/VError.js';
 export const readFiles = async () => {
-  const filePaths = clipboardEx.readFilePaths()
-  console.log(filePaths)
-  return {
-    source: 'electron-clipboard-ex',
-    type: 'copy', // TODO can't be sure on this
-    files: filePaths,
-  }
-}
-
+    const filePaths = clipboardEx.readFilePaths();
+    console.log(filePaths);
+    return {
+        source: 'electron-clipboard-ex',
+        type: 'copy', // TODO can't be sure on this
+        files: filePaths,
+    };
+};
 export const writeFiles = async (type, files) => {
-  try {
-    clipboardEx.writeFilePaths(files)
-  } catch (error) {
-    throw new VError(error, 'Failed to copy files to clipboard')
-  }
-}
+    try {
+        clipboardEx.writeFilePaths(files);
+    }
+    catch (error) {
+        throw new VError(error, 'Failed to copy files to clipboard');
+    }
+};

package/src/parts/CollectTextSearchStdout/CollectTextSearchStdout.js

@@ -1,103 +1,93 @@
-import { Writable } from 'node:stream'
-import { pipeline } from 'node:stream/promises'
-import * as EncodingType from '../EncodingType/EncodingType.js'
-import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
-import * as RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js'
-import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
-import * as ToTextSearchResult from '../ToTextSearchResult/ToTextSearchResult.js'
+import { Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import * as EncodingType from '../EncodingType/EncodingType.js';
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js';
+import * as RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js';
+import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js';
+import * as ToTextSearchResult from '../ToTextSearchResult/ToTextSearchResult.js';
 // TODO update vscode-ripgrep when https://github.com/mhinz/vim-grepper/issues/244, https://github.com/BurntSushi/ripgrep/issues/1892 is fixed
-
 // need to use '.' as last argument for ripgrep
 // issue 1 https://github.com/nvim-telescope/telescope.nvim/pull/908/files
 // issue 2 https://github.com/BurntSushi/ripgrep/issues/1892
 // remove workaround when ripgrep is fixed
-
 // TODO stats flag might not be necessary
 // TODO update client
 // TODO not always run nice, maybe configure nice via flag/options
-
 export const collectStdout = async (childProcess, maxSearchResults, charsBefore, charsAfter) => {
-  const allSearchResults = Object.create(null)
-  let buffer = ''
-  let stats = {}
-  let limitHit = false
-  let numberOfResults = 0
-
-  childProcess.stdout.setEncoding(EncodingType.Utf8)
-
-  const handleLine = (line) => {
-    const parsedLine = JSON.parse(line)
-    const { type, data } = parsedLine
-    switch (type) {
-      case RipGrepParsedLineType.Begin:
-        allSearchResults[data.path.text] = [
-          {
-            type: TextSearchResultType.File,
-            start: 0,
-            end: 0,
-            lineNumber: 0,
-            text: data.path.text,
-          },
-        ]
-        break
-      case RipGrepParsedLineType.Match:
-        const remaining = maxSearchResults - numberOfResults
-        const matches = ToTextSearchResult.toTextSearchResult(parsedLine, remaining, charsBefore, charsAfter)
-        numberOfResults += matches.length
-        allSearchResults[data.path.text].push(...matches)
-        break
-      case RipGrepParsedLineType.Summary:
-        stats = data
-        break
-      default:
-        break
-    }
-  }
-
-  const handleData = (chunk) => {
-    let newLineIndex = GetNewLineIndex.getNewLineIndex(chunk)
-    const dataString = buffer + chunk
-    if (newLineIndex === -1) {
-      buffer = dataString
-      return
-    }
-    newLineIndex += buffer.length
-    let previousIndex = 0
-    while (newLineIndex >= 0) {
-      const line = dataString.slice(previousIndex, newLineIndex)
-      handleLine(line)
-      previousIndex = newLineIndex + 1
-      newLineIndex = GetNewLineIndex.getNewLineIndex(dataString, previousIndex)
-    }
-    buffer = dataString.slice(previousIndex)
-
-    if (numberOfResults > maxSearchResults) {
-      limitHit = true
-      childProcess.kill()
-    }
-  }
-
-  await pipeline(
-    childProcess.stdout,
-    new Writable({
-      decodeStrings: false,
-      construct(callback) {
-        callback()
-      },
-      write(chunk, encoding, callback) {
-        try {
-          handleData(chunk)
-          callback()
-        } catch (error) {
-          callback(error)
+    const allSearchResults = Object.create(null);
+    let buffer = '';
+    let stats = {};
+    let limitHit = false;
+    let numberOfResults = 0;
+    childProcess.stdout.setEncoding(EncodingType.Utf8);
+    const handleLine = (line) => {
+        const parsedLine = JSON.parse(line);
+        const { type, data } = parsedLine;
+        switch (type) {
+            case RipGrepParsedLineType.Begin:
+                allSearchResults[data.path.text] = [
+                    {
+                        type: TextSearchResultType.File,
+                        start: 0,
+                        end: 0,
+                        lineNumber: 0,
+                        text: data.path.text,
+                    },
+                ];
+                break;
+            case RipGrepParsedLineType.Match:
+                const remaining = maxSearchResults - numberOfResults;
+                const matches = ToTextSearchResult.toTextSearchResult(parsedLine, remaining, charsBefore, charsAfter);
+                numberOfResults += matches.length;
+                allSearchResults[data.path.text].push(...matches);
+                break;
+            case RipGrepParsedLineType.Summary:
+                stats = data;
+                break;
+            default:
+                break;
         }
-      },
-    }),
-  )
-  const results = Object.values(allSearchResults).flat(1)
-  return {
-    results,
-    stats,
-    limitHit,
-  }
-}
+    };
+    const handleData = (chunk) => {
+        let newLineIndex = GetNewLineIndex.getNewLineIndex(chunk);
+        const dataString = buffer + chunk;
+        if (newLineIndex === -1) {
+            buffer = dataString;
+            return;
+        }
+        newLineIndex += buffer.length;
+        let previousIndex = 0;
+        while (newLineIndex >= 0) {
+            const line = dataString.slice(previousIndex, newLineIndex);
+            handleLine(line);
+            previousIndex = newLineIndex + 1;
+            newLineIndex = GetNewLineIndex.getNewLineIndex(dataString, previousIndex);
+        }
+        buffer = dataString.slice(previousIndex);
+        if (numberOfResults > maxSearchResults) {
+            limitHit = true;
+            childProcess.kill();
+        }
+    };
+    await pipeline(childProcess.stdout, new Writable({
+        decodeStrings: false,
+        construct(callback) {
+            callback();
+        },
+        write(chunk, encoding, callback) {
+            try {
+                handleData(chunk);
+                callback();
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+    }));
+    const results = Object.values(allSearchResults).flat(1);
+    return {
+        results,
+        stats,
+        limitHit,
+    };
+};

package/src/parts/ColorTheme/ColorTheme.js

@@ -1,21 +1,18 @@
-import * as JoinLines from '../JoinLines/JoinLines.js'
-
+import * as JoinLines from '../JoinLines/JoinLines.js';
 export const getColorThemeJson = async () => {
-  return {
-    MainBackground: '#1e2324',
-    TreeItemForeground: ` rgb(188, 190, 190)`,
-    FocusOutline: `#3d5252`,
-  }
-}
-
+    return {
+        MainBackground: '#1e2324',
+        TreeItemForeground: ` rgb(188, 190, 190)`,
+        FocusOutline: `#3d5252`,
+    };
+};
 const toInnerLine = ([key, value]) => {
-  return `  --${key}: ${value};`
-}
-
+    return `  --${key}: ${value};`;
+};
 export const toCss = (colorThemeJson) => {
-  const innerLines = Object.entries(colorThemeJson).map(toInnerLine)
-  const css = `:root {
+    const innerLines = Object.entries(colorThemeJson).map(toInnerLine);
+    const css = `:root {
 ${JoinLines.joinLines(innerLines)}
-}`
-  return css
-}
+}`;
+    return css;
+};

package/src/parts/Command/Command.js

@@ -1,80 +1,73 @@
-import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
-import * as ModuleMap from '../ModuleMap/ModuleMap.js'
-import { VError } from '../VError/VError.js'
-
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js';
+import * as ModuleMap from '../ModuleMap/ModuleMap.js';
+import { VError } from '../VError/VError.js';
 export const state = {
-  commands: Object.create(null),
-  pendingModules: Object.create(null),
-  async load(moduleId) {},
-}
-
+    commands: Object.create(null),
+    pendingModules: Object.create(null),
+    async load(moduleId) { },
+};
 const initializeModule = (module) => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = `${module.name}.${key}`
-        register(actualKey, value)
-      } else {
-        register(key, value)
-      }
+    if (module.Commands) {
+        for (const [key, value] of Object.entries(module.Commands)) {
+            if (module.name) {
+                const actualKey = `${module.name}.${key}`;
+                register(actualKey, value);
+            }
+            else {
+                register(key, value);
+            }
+        }
+        return;
     }
-    return
-  }
-  throw new Error(`module ${module.name} is missing an initialize function and commands`)
-}
-
+    throw new Error(`module ${module.name} is missing an initialize function and commands`);
+};
 const loadModule = async (moduleId) => {
-  try {
-    const module = await state.load(moduleId)
-    initializeModule(module)
-  } catch (error) {
-    if (error && error instanceof SyntaxError && error.stack === `SyntaxError: ${error.message}`) {
-      Error.captureStackTrace(error, loadModule)
+    try {
+        const module = await state.load(moduleId);
+        initializeModule(module);
     }
-    throw new VError(error, `failed to load module ${moduleId}`)
-  }
-}
-
+    catch (error) {
+        if (error && error instanceof SyntaxError && error.stack === `SyntaxError: ${error.message}`) {
+            Error.captureStackTrace(error, loadModule);
+        }
+        throw new VError(error, `failed to load module ${moduleId}`);
+    }
+};
 const getOrLoadModule = (moduleId) => {
-  if (!state.pendingModules[moduleId]) {
-    state.pendingModules[moduleId] = loadModule(moduleId)
-  }
-  return state.pendingModules[moduleId]
-}
-
+    if (!state.pendingModules[moduleId]) {
+        state.pendingModules[moduleId] = loadModule(moduleId);
+    }
+    return state.pendingModules[moduleId];
+};
 const loadCommand = async (command) => {
-  await getOrLoadModule(ModuleMap.getModuleId(command))
-}
-
+    await getOrLoadModule(ModuleMap.getModuleId(command));
+};
 export const register = (commandId, listener) => {
-  state.commands[commandId] = listener
-}
-
-const hasThrown = new Set()
-
+    state.commands[commandId] = listener;
+};
+const hasThrown = new Set();
 const executeCommandAsync = async (command, ...args) => {
-  try {
-    await loadCommand(command)
-  } catch (error) {
-    throw new VError(error, `Failed to load command ${command}`)
-  }
-  if (!(command in state.commands)) {
-    if (hasThrown.has(command)) {
-      return
+    try {
+        await loadCommand(command);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to load command ${command}`);
     }
-    hasThrown.add(command)
-    throw new CommandNotFoundError(command)
-  }
-  return state.commands[command](...args)
-}
-
+    if (!(command in state.commands)) {
+        if (hasThrown.has(command)) {
+            return;
+        }
+        hasThrown.add(command);
+        throw new CommandNotFoundError(command);
+    }
+    return state.commands[command](...args);
+};
 export const execute = (command, ...args) => {
-  if (command in state.commands) {
-    return state.commands[command](...args)
-  }
-  return executeCommandAsync(command, ...args)
-}
-
+    if (command in state.commands) {
+        return state.commands[command](...args);
+    }
+    return executeCommandAsync(command, ...args);
+};
 export const setLoad = (load) => {
-  state.load = load
-}
+    state.load = load;
+};

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -1,10 +1,9 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as ProcessDisplayName from '../ProcessDisplayName/ProcessDisplayName.js'
-
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as ProcessDisplayName from '../ProcessDisplayName/ProcessDisplayName.js';
 export class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`Command ${id} not found in ${ProcessDisplayName.processDisplayName}`)
-    this.name = 'CommandNotFoundError'
-    this.code = ErrorCodes.E_COMMAND_NOT_FOUND
-  }
+    constructor(id) {
+        super(`Command ${id} not found in ${ProcessDisplayName.processDisplayName}`);
+        this.name = 'CommandNotFoundError';
+        this.code = ErrorCodes.E_COMMAND_NOT_FOUND;
+    }
 }

package/src/parts/CompareVersion/CompareVersion.js

@@ -1,3 +1,3 @@
 export const isGreater = (version, otherVersion) => {
-  return true
-}
+    return true;
+};

package/src/parts/ContentSecurityPolicy/ContentSecurityPolicy.ipc.js

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

package/src/parts/ContentSecurityPolicy/ContentSecurityPolicy.js

@@ -1,8 +1,7 @@
-import * as Assert from '../Assert/Assert.js'
-import * as ContentSecurityPolicyState from '../ContentSecurityPolicyState/ContentSecurityPolicyState.js'
-
+import * as Assert from '../Assert/Assert.js';
+import * as ContentSecurityPolicyState from '../ContentSecurityPolicyState/ContentSecurityPolicyState.js';
 export const set = (url, contentSecurityPolicy) => {
-  Assert.string(url)
-  Assert.string(contentSecurityPolicy)
-  ContentSecurityPolicyState.set(url, contentSecurityPolicy)
-}
+    Assert.string(url);
+    Assert.string(contentSecurityPolicy);
+    ContentSecurityPolicyState.set(url, contentSecurityPolicy);
+};

package/src/parts/ContentSecurityPolicyDocument/ContentSecurityPolicyDocument.js

@@ -1,11 +1,10 @@
-import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js'
-
+import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
 export const value = GetContentSecurityPolicy.getContentSecurityPolicy([
-  `default-src 'none'`,
-  `font-src 'self'`,
-  `frame-src *`,
-  `img-src 'self' https: data:`,
-  `script-src 'self'`,
-  `media-src 'self'`,
-  `style-src 'self'`,
-])
+    `default-src 'none'`,
+    `font-src 'self'`,
+    `frame-src *`,
+    `img-src 'self' https: data:`,
+    `script-src 'self'`,
+    `media-src 'self'`,
+    `style-src 'self'`,
+]);

package/src/parts/ContentSecurityPolicyState/ContentSecurityPolicyState.js

@@ -1,9 +1,7 @@
-const map = Object.create(null)
-
+const map = Object.create(null);
 export const set = (url, contentSecurityPolicy) => {
-  map[url] = contentSecurityPolicy
-}
-
+    map[url] = contentSecurityPolicy;
+};
 export const get = (url) => {
-  return map[url]
-}
+    return map[url];
+};

package/src/parts/ContentSecurityPolicySyntaxHighlightingWorker/ContentSecurityPolicySyntaxHighlightingWorker.js

@@ -1,3 +1,2 @@
-import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js'
-
-export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`])
+import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
+export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`]);

package/src/parts/ContentSecurityPolicyTerminalWorker/ContentSecurityPolicyTerminalWorker.js

@@ -1,3 +1,2 @@
-import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js'
-
-export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`, `connect-src 'self'`])
+import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
+export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`, `connect-src 'self'`]);