@lvce-editor/shared-process 0.0.41 → 0.2.0

package/src/parts/JsonFile/JsonFile.js

@@ -1,14 +1,14 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import * as Path from '../Path/Path.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Json from '../Json/Json.js'
+import * as Path from '../Path/Path.js'
 
 export const readJson = async (absolutePath) => {
-  const content = await readFile(absolutePath, 'utf-8')
+  const content = await FileSystem.readFile(absolutePath)
   const json = await Json.parse(content, absolutePath)
   return json
 }
 
 export const writeJson = async (absolutePath, value) => {
-  await mkdir(Path.dirname(absolutePath), { recursive: true })
-  await writeFile(absolutePath, Json.stringify(value))
+  await FileSystem.mkdir(Path.dirname(absolutePath))
+  await FileSystem.writeFile(absolutePath, Json.stringify(value))
 }

package/src/parts/Native/Native.js

@@ -1,14 +1,10 @@
 import open from 'open'
-import * as Error from '../Error/Error.js'
+import VError from 'verror'
 
 export const openFolder = async (path) => {
   try {
     await open(path)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_OPEN_SYSTEM_ERROR',
-      message: `Failed to open ${path}`,
-    })
+    throw new VError(error, `Failed to open ${path}`)
   }
 }

package/src/parts/Preferences/Preferences.js

@@ -11,7 +11,7 @@ export const getUserPreferences = async () => {
     try {
       json = await JsonFile.readJson(userSettingsPath)
     } catch (error) {
-      if (error && error.code === 'ENOENT') {
+      if (error && error.message.includes('File not found')) {
         return {}
       }
       throw error

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

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

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -0,0 +1,52 @@
+import VError from 'verror'
+import * as Assert from '../Assert/Assert.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Json from '../Json/Json.js'
+import * as Platform from '../Platform/Platform.js'
+
+const isValid = (recentlyOpened) => {
+  return recentlyOpened && Array.isArray(recentlyOpened)
+}
+
+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 getRecentlyOpened = async (recentlyOpenedPath) => {
+  try {
+    const content = await FileSystem.readFile(recentlyOpenedPath)
+    const parsed = await Json.parse(content, recentlyOpenedPath)
+    return parsed
+  } catch (error) {
+    // TODO should check for error.code
+    if (error.message.includes('File not found')) {
+      // ignore
+    } else if (error.message.includes('Json Parsing Error')) {
+      // ignore
+    } else {
+      throw new VError(error, `Failed to read recently opened`)
+    }
+    return []
+  }
+}
+
+const setRecentlyOpened = async (recentlyOpenedPath, newRecentlyOpened) => {
+  const stringified = Json.stringify(newRecentlyOpened)
+  await FileSystem.writeFile(recentlyOpenedPath, stringified)
+}
+
+export const addPath = async (path) => {
+  Assert.string(path)
+  const recentlyOpenedPath = Platform.getRecentlyOpenedPath()
+  const parsed = await getRecentlyOpened(recentlyOpenedPath)
+  const newRecentlyOpened = addToArrayUnique(parsed, path)
+  await setRecentlyOpened(recentlyOpenedPath, newRecentlyOpened)
+}

package/src/parts/Search/Search.js

@@ -22,6 +22,12 @@ const useNice = !Platform.isWindows()
 // TODO update client
 // TODO not always run nice, maybe configure nice via flag/options
 
+const ParsedLineType = {
+  Begin: 'begin',
+  Match: 'match',
+  Summary: 'summary',
+}
+
 export const search = async (searchDir, searchString) => {
   // TODO reject promise when ripgrep search fails
   return new Promise((resolve, reject) => {
@@ -61,18 +67,18 @@ export const search = async (searchDir, searchString) => {
       for (const line of lines) {
         const parsedLine = JSON.parse(line)
         switch (parsedLine.type) {
-          case 'begin': {
+          case ParsedLineType.Begin: {
             allSearchResults[parsedLine.data.path.text] = []
             break
           }
-          case 'match': {
+          case ParsedLineType.Match: {
             numberOfResults++
             allSearchResults[parsedLine.data.path.text].push(
               toSearchResult(parsedLine)
             )
             break
           }
-          case 'summary':
+          case ParsedLineType.Summary:
             stats = parsedLine.data
             break
           default:

package/src/parts/Electron/Electron.ipc.js

@@ -1,18 +0,0 @@
-import * as Electron from './Electron.js'
-
-export const Commands = {
-  'Electron.toggleDevtools': Electron.toggleDevtools,
-  'Electron.windowMinimize': Electron.windowMinimize,
-  'Electron.windowMaximize': Electron.windowMaximize,
-  'Electron.windowUnmaximize': Electron.windowUnmaximize,
-  'Electron.windowClose': Electron.windowClose,
-  'Electron.about': Electron.about,
-  'Electron.showOpenDialog': Electron.showOpenDialog,
-  'Electron.windowReload': Electron.windowReload,
-  'Electron.getPerformanceEntries': Electron.getPerformanceEntries,
-  'Electron.crashMainProcess': Electron.crashMainProcess,
-  'Electron.showMessageBox': Electron.showMessageBox,
-  'Electron.windowOpenNew': Electron.windowOpenNew,
-  'Electron.exit': Electron.exit,
-  'Electron.openProcessExplorer': Electron.openProcessExplorer,
-}

package/src/parts/Electron/Electron.js

@@ -1,110 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as ParentIpc from '../ParentIpc/ParentIpc.js'
-
-export const state = {
-  send(message) {
-    ParentIpc.electronSend(message)
-  },
-  async invoke(method, ...params) {
-    return new Promise((resolve, reject) => {
-      // TODO use one map instead of two
-      const callbackId = Callback.register(resolve, reject)
-      state.send({
-        jsonrpc: '2.0',
-        method,
-        params,
-        id: callbackId,
-      })
-    })
-  },
-}
-
-const send = (method, ...params) => {
-  state.send({
-    jsonrpc: '2.0',
-    method,
-    params,
-  })
-}
-
-const invoke = async (method, ...params) => {
-  return state.invoke(method, ...params)
-}
-
-export const toggleDevtools = async () => {
-  await invoke(/* Window.toggleDevtools */ 'Window.toggleDevtools')
-}
-
-export const windowMinimize = async () => {
-  await invoke(/* Window.minimize */ 'Window.minimize')
-}
-
-export const windowMaximize = async () => {
-  await invoke(/* Window.maximize */ 'Window.maximize')
-}
-
-export const windowUnmaximize = async () => {
-  await invoke(/* Window.unmaximize */ 'Window.unmaximize')
-}
-
-export const windowClose = async () => {
-  await invoke(/* Window.close */ 'Window.close')
-}
-
-export const windowReload = async () => {
-  await invoke(/* Window.reload */ 'Window.reload')
-}
-
-// TODO move these into separate files like done extension host
-
-export const windowOpenNew = async () => {
-  await invoke(/* AppWindow.openNew */ 'AppWindow.openNew')
-}
-
-export const about = async () => {
-  await invoke(/* About.open */ 'About.open')
-}
-
-export const showOpenDialog = async (title, properties) => {
-  const result = await invoke(
-    /* Dialog.showOpenDialog */ 'Dialog.showOpenDialog',
-    /* title */ title,
-    /* properties */ properties
-  )
-  return result
-}
-
-export const showMessageBox = async (message, buttons) => {
-  const result = await invoke(
-    /* Dialog.showMessageBox */ 'Dialog.showMessageBox',
-    message,
-    buttons
-  )
-  return result
-}
-
-export const crashMainProcess = async () => {
-  await invoke(/* Developer.crashMainProcess */ 'Developer.crashMainProcess')
-}
-
-export const getPerformanceEntries = async () => {
-  const result = await invoke(
-    /* Developer.getPerformanceEntries */ 'Developer.getPerformanceEntries'
-  )
-  return result
-}
-
-export const beep = async () => {
-  // TODO when is remote should send to renderer worker
-  await invoke(/* Beep.beep */ 'Beep.beep')
-}
-
-export const exit = async () => {
-  await invoke(/* App.exit */ 'App.exit')
-}
-
-export const openProcessExplorer = async () => {
-  await invoke(
-    /* ProcessExplorer.openProcessExplorer */ 'ProcessExplorer.openProcessExplorer'
-  )
-}