@lvce-editor/shared-process 0.0.2

package/src/parts/Path/Path.js

@@ -0,0 +1,17 @@
+import * as NodePath from 'node:path'
+
+export const getHomeDir = () => {}
+
+export const getTmpDir = () => {}
+
+export const getBuiltinExtensionDir = () => {}
+
+export const getMarketplaceExtensionDir = () => {}
+
+export const join = (...parts) => {
+  return NodePath.join(...parts)
+}
+
+export const dirname = (path) => {
+  return NodePath.dirname(path)
+}

package/src/parts/Platform/Platform.ipc.js

@@ -0,0 +1,18 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const __initialize__ = () => {
+  Command.register('Platform.getConfigDir', Platform.getConfigDir)
+  Command.register('Platform.getAppDir', Platform.getAppDir)
+  Command.register('Platform.getHomeDir', Platform.getHomeDir)
+  Command.register('Platform.getDataDir', Platform.getDataDir)
+  Command.register('Platform.getExtensionsPath', Platform.getExtensionsPath)
+  Command.register('Platform.getBuiltinExtensionsPath', Platform.getBuiltinExtensionsPath)
+  Command.register('Platform.getDisabledExtensionsPath', Platform.getDisabledExtensionsPath)
+  Command.register('Platform.getCachedExtensionsPath', Platform.getCachedExtensionsPath)
+  Command.register('Platform.getMarketplaceUrl', Platform.getMarketplaceUrl)
+  Command.register('Platform.getLogsDir', Platform.getLogsDir)
+  Command.register('Platform.getUserSettingsPath', Platform.getUserSettingsPath)
+  Command.register('Platform.getRecentlyOpenedPath', Platform.getRecentlyOpenedPath)
+  Command.register('Platform.getCacheDir', Platform.getCacheDir)
+}

package/src/parts/Platform/Platform.js

@@ -0,0 +1,165 @@
+import { homedir, tmpdir } from 'node:os'
+import { sep } from 'node:path'
+import { xdgCache, xdgConfig, xdgData, xdgState } from 'xdg-basedir'
+import * as Root from '../Root/Root.js'
+import * as Path from '../Path/Path.js'
+import { extensionHostPath } from '@lvce-editor/extension-host'
+
+export const state = {
+  getApplicationName() {
+    return 'lvce-oss'
+  },
+  isWindows() {
+    return process.platform === 'win32'
+  },
+  isMacOs() {
+    return process.platform === 'darwin'
+  },
+  getDataDir() {
+    return Path.join(xdgData || tmpdir(), this.getApplicationName())
+  },
+  getConfigDir() {
+    return Path.join(xdgConfig || tmpdir(), this.getApplicationName())
+  },
+  getCacheDir() {
+    return Path.join(xdgCache || tmpdir(), this.getApplicationName())
+  },
+  getAppDir() {
+    return Root.root
+  },
+  getExtensionsPath() {
+    return Path.join(this.getDataDir(), 'extensions')
+  },
+  getBuiltinExtensionsPath() {
+    return Path.join(Root.root, 'extensions')
+  },
+  getDisabledExtensionsPath() {
+    return Path.join(this.getDataDir(), 'disabled-extensions')
+  },
+  getCachedExtensionsPath() {
+    return Path.join(this.getCacheDir(), 'cached-extensions')
+  },
+  getMarketplaceUrl() {
+    return (
+      process.env.LVCE_MARKETPLACE_URL ||
+      'https://marketplace.22e924c84de072d4b25b.com'
+    )
+  },
+  getDesktop() {
+    if (
+      process.env.ORIGINAL_XDG_CURRENT_DESKTOP &&
+      process.env.ORIGINAL_XDG_CURRENT_DESKTOP !== 'undefined'
+    ) {
+      if (process.env.ORIGINAL_XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
+        return 'gnome'
+      }
+      return process.env.ORIGINAL_XDG_CURRENT_DESKTOP
+    }
+    if (process.env.XDG_CURRENT_DESKTOP) {
+      if (process.env.XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
+        return 'gnome'
+      }
+      return process.env.XDG_CURRENT_DESKTOP
+    }
+    if (process.platform === 'win32') {
+      return 'windows'
+    }
+    return ''
+  },
+  getPathSeparator() {
+    return sep
+  },
+  getStateDir() {
+    return xdgState
+  },
+  getLogsDir() {
+    return Path.join(xdgState || tmpdir(), this.getApplicationName(), 'logs')
+  },
+  getUserSettingsPath() {
+    return Path.join(this.getConfigDir(), 'settings.json')
+  },
+  getExtensionHostPath() {
+    return extensionHostPath
+  },
+  getRecentlyOpenedPath() {
+    return Path.join(this.getCacheDir(), 'recently-opened.json')
+  },
+}
+
+export const isWindows = () => {
+  return state.isWindows()
+}
+
+export const isMacOs = () => {
+  return state.isMacOs()
+}
+
+// TODO pass which version when building: insiders|oss|normal
+
+export const getDataDir = () => {
+  return state.getDataDir()
+}
+
+export const getConfigDir = () => {
+  return state.getConfigDir()
+}
+
+export const getCacheDir = () => {
+  return state.getCacheDir()
+}
+
+export const getHomeDir = () => {
+  return isWindows() ? '' : homedir()
+}
+
+export const getAppDir = () => {
+  return state.getAppDir()
+}
+
+export const getExtensionsPath = () => {
+  return state.getExtensionsPath()
+}
+
+export const getBuiltinExtensionsPath = () => {
+  return state.getBuiltinExtensionsPath()
+}
+
+export const getDisabledExtensionsPath = () => {
+  return state.getDisabledExtensionsPath()
+}
+
+export const getCachedExtensionsPath = () => {
+  return state.getCachedExtensionsPath()
+}
+
+export const getMarketplaceUrl = () => {
+  return state.getMarketplaceUrl()
+}
+
+export const getDesktop = () => {
+  return state.getDesktop()
+}
+
+export const getPathSeparator = () => {
+  return state.getPathSeparator()
+}
+
+export const getStateDir = () => {
+  return state.getStateDir()
+}
+
+export const getLogsDir = () => {
+  return state.getLogsDir()
+}
+
+export const getUserSettingsPath = () => {
+  return state.getUserSettingsPath()
+}
+
+export const getExtensionHostPath = () => {
+  return state.getExtensionHostPath()
+}
+
+export const getRecentlyOpenedPath = () => {
+  return state.getRecentlyOpenedPath()
+}

package/src/parts/Preferences/Preferences.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as Preferences from '../Preferences/Preferences.js'
+
+export const __initialize__ = () => {
+  Command.register("Preferences.getAll", Preferences.getAll)
+}

package/src/parts/Preferences/Preferences.js

@@ -0,0 +1,75 @@
+import { join } from 'node:path'
+import VError from 'verror'
+import * as JsonFile from '../JsonFile/JsonFile.js'
+import * as Platform from '../Platform/Platform.js'
+
+const CACHED_SETTINGS_PATH = '~/.cache/vscode/cachedSettings.json'
+// TODO need jsonc parser for settings with comments
+
+export const getUserPreferences = async () => {
+  try {
+    const userSettingsPath = Platform.getUserSettingsPath()
+    let json
+    try {
+      json = await JsonFile.readJson(userSettingsPath)
+    } catch (error) {
+      if (error && error.code === 'ENOENT') {
+        return {}
+      }
+      throw error
+    }
+    return json
+  } catch (error) {
+    throw new VError(error, 'failed to get user preferences')
+  }
+}
+
+// TODO handle error
+export const getDefaultPreferences = async () => {
+  try {
+    const defaultSettingsPath = join(
+      Platform.getAppDir(),
+      'static',
+      'config',
+      'defaultSettings.json'
+    )
+    return await JsonFile.readJson(defaultSettingsPath)
+  } catch (error) {
+    throw new VError(error, 'Failed to load default preferences')
+  }
+}
+
+// TODO efficiently load preferences -> first load cached preferences
+//                                   -> on idle check preferences
+
+// TODO compare with timestamp/hash that preferences are fresh
+export const getAll = async () => {
+  try {
+    // try {
+    //   const cachedPreferences = JSON.parse(
+    //     await readFile(CACHED_SETTINGS_PATH, 'utf-8')
+    //   )
+    //   return cachedPreferences
+    // } catch {
+    //   // ignore
+    // }
+    const defaultPreferences = await getDefaultPreferences()
+    const userPreferences = await getUserPreferences()
+    // TODO separate backend and frontend preferences, ui only needs frontend preferences
+    const preferences = { ...defaultPreferences, ...userPreferences }
+    // try {
+    //   await mkdir(dirname(CACHED_SETTINGS_PATH), { recursive: true })
+    //   await writeFile(
+    //     CACHED_SETTINGS_PATH,
+    //     JSON.stringify(preferences, null, 2) + '\n'
+    //   )
+    // } catch {
+    //   // ignore
+    // }
+    return preferences
+  } catch (error) {
+    throw new VError(error, 'Failed to get all preferences')
+  }
+}
+
+// TODO when preferences cannot be loaded, ui should show useful error message

package/src/parts/PrettyError/PrettyError.js

@@ -0,0 +1,86 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { codeFrameColumns } from '@babel/code-frame'
+import cleanStack from 'clean-stack'
+import { LinesAndColumns } from 'lines-and-columns'
+
+const getActualPath = (fileUri) => {
+  if (fileUri.startsWith('file://')) {
+    return fileURLToPath(fileUri)
+  }
+  return fileUri
+}
+
+export const prepare = (error) => {
+  const message = error.message
+  if (error.cause) {
+    error = error.cause()
+  }
+  const cleanedStack = cleanStack(error.stack)
+  const lines = cleanedStack.split('\n')
+  const file = lines[1]
+  let codeFrame = ''
+  if (error.codeFrame) {
+    codeFrame = error.codeFrame
+  } else if (file) {
+    let match = file.match(/\((.*):(\d+):(\d+)\)$/)
+    if (!match) {
+      match = file.match(/at (.*):(\d+):(\d+)$/)
+    }
+    if (match) {
+      const [_, path, line, column] = match
+      const actualPath = getActualPath(path)
+      const rawLines = readFileSync(actualPath, 'utf-8')
+      const location = {
+        start: {
+          line: Number.parseInt(line),
+          column: Number.parseInt(column),
+        },
+      }
+
+      codeFrame = codeFrameColumns(rawLines, location)
+    }
+  }
+  const relevantStack = lines.slice(1).join('\n')
+  return {
+    message,
+    stack: relevantStack,
+    codeFrame,
+  }
+}
+
+const fixBackslashes = (string) => {
+  return string.replaceAll('\\\\', '\\')
+}
+
+const stringifyJson = (json) => {
+  return JSON.stringify(json, null, 2) + '\n'
+}
+
+export const prepareJsonError = (json, property, message) => {
+  const string = fixBackslashes(stringifyJson(json))
+  const stringifiedPropertyName = `"${property}"`
+  const index = string.indexOf(stringifiedPropertyName) // TODO this could be wrong in some cases, find a better way
+  console.log({ string, index })
+  const jsonError = {
+    stack: '',
+  }
+  if (index !== -1) {
+    const lines = new LinesAndColumns(string)
+    const location = lines.locationForIndex(
+      index + stringifiedPropertyName.length + 1
+    )
+    const codeFrame = codeFrameColumns(string, {
+      start: { line: location.line + 1, column: location.column + 1 },
+    })
+    jsonError.codeFrame = codeFrame
+  }
+  // jsonError.stack = `${bottomMessage}\n    at ${filePath}`
+  return jsonError
+}
+
+export const print = (prettyError) => {
+  console.error(
+    `Error: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}`
+  )
+}

package/src/parts/Process/Process.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Process from './Process.js'
+
+export const __initialize__ = () => {
+  Command.register(555, Process.crash)
+  Command.register(556, Process.crashAsync)
+}

package/src/parts/Process/Process.js

@@ -0,0 +1,7 @@
+export const crash = (message) => {
+  throw new Error(message)
+}
+
+export const crashAsync = async (message) => {
+  throw new Error(message)
+}

package/src/parts/Queue/Queue.js

@@ -0,0 +1,35 @@
+export const state = {
+  queueMap: Object.create(null),
+}
+
+const run = async (queue) => {
+  if (queue.state === 'running') {
+    return
+  }
+  queue.state = 'running'
+  let item
+  while ((item = queue.items.shift())) {
+    try {
+      await item.fn()
+      item.resolve()
+    } catch (error) {
+      item.reject(error)
+    }
+  }
+  queue.state = 'idle'
+}
+
+export const add = async (key, fn) => {
+  const queue = (state.queueMap[key] ||= {
+    state: 'idle',
+    items: [],
+  })
+  await new Promise((resolve, reject) => {
+    queue.items.push({
+      fn,
+      resolve,
+      reject,
+    })
+    run(queue)
+  })
+}

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -0,0 +1,11 @@
+// TODO find a better way to do this
+// most commands don't require sockets
+// but output channel and terminal need to continuously send data through the socket
+const METHODS_THAT_REQUIRE_SOCKET = [
+  'OutputChannel.open', // OutputChannel.open
+  'ExtensionHost.start', // ExtensionHost.start
+]
+
+export const requiresSocket = (method) => {
+  return METHODS_THAT_REQUIRE_SOCKET.includes(method)
+}

package/src/parts/RgPath/RgPath.js

@@ -0,0 +1 @@
+export { rgPath } from 'vscode-ripgrep-with-github-api-error-fix'

package/src/parts/Root/Root.js

@@ -0,0 +1,6 @@
+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/Search/Search.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as Search from './Search.js'
+
+export const __initialize__ = () => {
+  Command.register('Search.search', Search.search)
+}

package/src/parts/Search/Search.js

@@ -0,0 +1,101 @@
+import { spawn } from 'node:child_process'
+import * as RgPath from '../RgPath/RgPath.js'
+import * as Platform from '../Platform/Platform.js'
+
+const MAX_SEARCH_RESULTS = 300
+
+const toSearchResult = (parsedLine) => ({
+  preview: parsedLine.data.lines.text,
+  absoluteOffset: parsedLine.data.absolute_offset,
+})
+
+// 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 no function call at toplevel!
+const useNice = !Platform.isWindows()
+// TODO stats flag might not be necessary
+// TODO update client
+// TODO not always run nice, maybe configure nice via flag/options
+
+export const search = async (searchDir, searchString) => {
+  // TODO reject promise when ripgrep search fails
+  return new Promise((resolve, reject) => {
+    const childProcess = useNice
+      ? spawn(
+          'nice',
+          [
+            '-20',
+            RgPath.rgPath,
+            '--smart-case',
+            '--stats',
+            '--json',
+            searchString,
+            '.',
+          ],
+          {
+            cwd: searchDir,
+          }
+        )
+      : spawn(
+          RgPath.rgPath,
+          ['--smart-case', '--stats', '--json', searchString, '.'],
+          {
+            cwd: searchDir,
+          }
+        )
+    const allSearchResults = Object.create(null)
+    let buffer = ''
+    let stats = {}
+    let numberOfResults = 0
+    // TODO use pipeline / transform stream maybe
+    childProcess.stdout.on('data', (chunk) => {
+      buffer += chunk
+      const lines = buffer.split('\n')
+      // @ts-ignore
+      buffer = lines.pop()
+      for (const line of lines) {
+        const parsedLine = JSON.parse(line)
+        switch (parsedLine.type) {
+          case 'begin': {
+            allSearchResults[parsedLine.data.path.text] = []
+            break
+          }
+          case 'match': {
+            numberOfResults++
+            allSearchResults[parsedLine.data.path.text].push(
+              toSearchResult(parsedLine)
+            )
+            break
+          }
+          case 'summary':
+            stats = parsedLine.data
+            break
+          default:
+            break
+        }
+      }
+      if (numberOfResults > MAX_SEARCH_RESULTS) {
+        childProcess.kill()
+      }
+    })
+    childProcess.once('close', () => {
+      resolve({
+        results: Object.entries(allSearchResults),
+        stats,
+      })
+    })
+    childProcess.once('error', (error) => {
+      // TODO check type of error
+      console.error(error)
+      resolve({
+        results: [],
+        stats,
+      })
+    })
+  })
+}

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

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as SearchFile from './SearchFile.js'
+
+export const __initialize__ = () => {
+  Command.register('SearchFile.searchFile', SearchFile.searchFile)
+}

package/src/parts/SearchFile/SearchFile.js

@@ -0,0 +1,51 @@
+import * as RgPath from '../RgPath/RgPath.js'
+import * as Exec from '../Exec/Exec.js'
+
+const ripGrepPath = process.env.RIP_GREP_PATH || RgPath.rgPath
+
+const isEnoentErrorLinux = (error) => {
+  return error.code === 'ENOENT'
+}
+
+const isEnoentErrorWindows = (error) => {
+  return error.message.includes('The system cannot find the path specified.')
+}
+
+const isEnoentError = (error) => {
+  if (!error) {
+    return false
+  }
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error)
+}
+
+// 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 (path, searchTerm) => {
+  try {
+    const { stdout, stderr } = await Exec.exec(
+      ripGrepPath,
+      ['--files', '--sort-files'],
+      {
+        cwd: path,
+      }
+    )
+    const lines = stdout.split('\n')
+    return lines
+  } catch (error) {
+    // @ts-ignore
+    if (isEnoentError(error)) {
+      console.info(`[info] ripgrep could not be found at "${ripGrepPath}"`)
+      return []
+    }
+    // @ts-ignore
+    if (error && error.stderr === '') {
+      return []
+    }
+    console.error(error)
+    return []
+  }
+}