@lvce-editor/server 0.0.41 → 0.2.0

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.js

@@ -2,9 +2,9 @@ import * as Command from '../Command/Command.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js' // TODO use Command.execute instead
 import * as ExtensionsMarketplace from '../ExtensionMarketplace/ExtensionMarketplace.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Assert from '../Assert/Assert.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 
 export const ITEM_HEIGHT = 62
 
@@ -50,6 +50,7 @@ export const create = (id, uri, left, top, width, height) => {
     top,
     left,
     finalDeltaY: 2728,
+    error: '',
   }
 }
 
@@ -127,10 +128,10 @@ const getIcon = (extension) => {
   if (!extension || !extension.path || !extension.icon) {
     return ''
   }
-  if (Platform.getPlatform() === 'remote') {
+  if (Platform.platform === 'remote') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
-  if (Platform.getPlatform() === 'electron') {
+  if (Platform.platform === 'electron') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
   return ''
@@ -337,15 +338,11 @@ export const handleInput = async (state, value) => {
     // TODO handle out of order responses (a bit complicated)
     // for now just assume everything comes back in order
   } catch (error) {
-    ErrorHandling.handleError(error)
-    // console.error(error)
-    // TODO show error in viewlet
-    await RendererProcess.invoke(
-      /* viewletSend */ 'Viewlet.send',
-      /* id */ 'Extensions',
-      /* method */ 'setError',
-      /* error */ `Failed to load extensions from marketplace: ${error}`
-    )
+    ErrorHandling.printError(error)
+    return {
+      ...state,
+      error: `Failed to load extensions from marketplace: ${error}`,
+    }
   }
 }
 
@@ -552,14 +549,19 @@ export const handleDisable = async (state, id) => {
   )
 }
 
+const handleContextMenuMouse = (state, x, y) => {}
+
+const handleContextMenuIndex = (state, index) => {}
+
 // TODO pass index instead
-export const handleContextMenu = async (state, x, y, extensionId) => {
+export const handleContextMenu = async (state, x, y, index) => {
   await Command.execute(
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
     /* id */ 'manageExtension'
   )
+  return state
 }
 
 export const openSuggest = async (state) => {
@@ -791,10 +793,25 @@ const renderScrollBarY = {
   },
 }
 
+const renderError = {
+  isEqual(oldState, newState) {
+    return oldState.error === newState.error
+  },
+  apply(oldState, newState) {
+    return [
+      /* viewletSend */ 'Viewlet.send',
+      /* id */ 'Extensions',
+      /* method */ 'setError',
+      /* error */ newState.error,
+    ]
+  },
+}
+
 export const render = [
   renderHeight,
   renderFocusedIndex,
   renderScrollBarY,
   renderNegativeMargin,
   renderExtensions,
+  renderError,
 ]

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.js

@@ -270,7 +270,7 @@ export const openUri = async (state, uri) => {
   )
   // @ts-ignore
 
-  return ViewletManager.load(instance)
+  return ViewletManager.load(instance, true)
 }
 
 export const save = () => {

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -150,6 +150,9 @@ export const load = async (viewlet, focus = false) => {
     const oldVersion =
       viewletState.version === undefined ? undefined : ++viewletState.version
     let newState = await module.loadContent(viewletState)
+    if (focus && module.focus) {
+      newState = await module.focus(newState)
+    }
     if (viewletState.version !== oldVersion) {
       newState = viewletState
       console.log('version mismatch')

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -3,6 +3,7 @@ import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
 import * as QuickPickEveryThing from '../QuickPick/QuickPickEverything.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as InputEventType from '../InputEventType/InputEventType.js'
 // TODO send open signal to renderer process before items are ready
 // that way user can already type while items are still loading
 
@@ -396,23 +397,23 @@ const getNewValueDeleteWordForward = (value, selectionStart, selectionEnd) => {
 
 const getNewValue = (value, inputType, data, selectionStart, selectionEnd) => {
   switch (inputType) {
-    case 'insertText':
+    case InputEventType.InsertText:
       return getNewValueInsertText(value, data, selectionStart, selectionEnd)
-    case 'deleteContentBackward':
+    case InputEventType.DeleteContentBackward:
       return getNewValueDeleteContentBackward(
         value,
         selectionStart,
         selectionEnd
       )
-    case 'deleteContentForward':
+    case InputEventType.DeleteContentForward:
       return getNewValueDeleteContentForward(
         value,
         selectionStart,
         selectionEnd
       )
-    case 'deleteWordForward':
+    case InputEventType.DeleteWordForward:
       return getNewValueDeleteWordForward(value, selectionStart, selectionEnd)
-    case 'deleteWordBackward':
+    case InputEventType.DeleteWordBackward:
       return getNewValueDeleteWordBackward(value, selectionStart, selectionEnd)
     default:
       throw new Error(`unsupported input type ${inputType}`)

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.ipc.js

@@ -6,6 +6,8 @@ export const Commands = {
   'Search.handleInput': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleInput),
   'Search.handleClick': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleClick),
   'Search.setValue': Viewlet.wrapViewletCommand('Search', ViewletSearch.setValue),
+  'Search.handleContextMenuMouseAt': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleContextMenuMouseAt),
+  'Search.handleContextMenuKeyboard': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleContextMenuKeyboard),
 }
 
 export * from './ViewletSearch.js'

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.js

@@ -1,10 +1,11 @@
 import * as Command from '../Command/Command.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as I18nString from '../I18NString/I18NString.js'
 import * as TextSearch from '../TextSearch/TextSearch.js'
 import * as Workspace from '../Workspace/Workspace.js'
-import * as I18nString from '../I18NString/I18NString.js'
-
+import * as Compare from '../Compare/Compare.js'
+import * as Assert from '../Assert/Assert.js'
+import * as IconTheme from '../IconTheme/IconTheme.js'
+import * as SearchResultType from '../SearchResultType/SearchResultType.js'
 // TODO maybe create should have a container as param like vscode?
 // maybe not?
 
@@ -30,7 +31,7 @@ export const uiStrings = {
   ManyResultsInManyFiles: `Found {PH1} results in {PH2} files`,
 }
 
-export const create = () => {
+export const create = (id, uri, left, top, width, height) => {
   return {
     searchResults: [],
     stats: {},
@@ -38,6 +39,10 @@ export const create = () => {
     value: '',
     disposed: false,
     fileCount: 0,
+    left,
+    top,
+    width,
+    height,
   }
 }
 
@@ -88,6 +93,7 @@ export const setValue = async (state, value) => {
     const root = Workspace.state.workspacePath
     const results = await TextSearch.textSearch(root, value)
     const displayResults = toDisplayResults(results)
+    console.log({ results, displayResults })
     const resultCount = getResultCounts(results)
     const fileResultCount = results.length
     const message = getStatusMessage(resultCount, fileResultCount)
@@ -106,26 +112,10 @@ export const setValue = async (state, value) => {
   }
 }
 
-export const handleResult = async (state, result) => {
-  if (result.version !== state.version) {
-    return
-  }
-  await RendererProcess.invoke(
-    /* viewletInvoke */ 'Viewlet.send',
-    /* id */ state.id,
-    /* method */ 'handleSearchResult',
-    /* result */ result
-  )
-}
-
 export const dispose = async (state) => {
   // TODO cancel pending search
   if (state.state === 'searching') {
-    // TODO this should be invoke
-    await SharedProcess.invoke(
-      /* Search.cancel */ 'Search.cancel',
-      /* searchId */ state.searchId
-    )
+    await TextSearch.cancel(state.searchId)
   }
   return {
     ...state,
@@ -137,10 +127,14 @@ const getPath = (result) => {
   return result[0]
 }
 
+const getPreviews = (result) => {
+  return result[1]
+}
+
 const compareResults = (resultA, resultB) => {
   const pathA = getPath(resultA)
   const pathB = getPath(resultB)
-  return pathA.localeCompare(pathB)
+  return Compare.compareString(pathA, pathB)
 }
 
 const toDisplayResults = (results) => {
@@ -148,11 +142,23 @@ const toDisplayResults = (results) => {
   const displayResults = []
   for (const result of results) {
     const path = getPath(result)
+    const previews = getPreviews(result)
     const absolutePath = Workspace.getAbsolutePath(path)
+    const baseName = Workspace.pathBaseName(path)
     displayResults.push({
-      path: absolutePath,
-      name: path,
+      title: absolutePath,
+      type: SearchResultType.File,
+      text: baseName,
+      icon: IconTheme.getFileIcon({ name: baseName }),
     })
+    for (const preview of previews) {
+      displayResults.push({
+        title: preview.preview,
+        type: SearchResultType.Preview,
+        text: preview.preview,
+        icon: '',
+      })
+    }
   }
   return displayResults
 }
@@ -166,20 +172,81 @@ const toDisplayResults = (results) => {
 // TODO send results to renderer process
 // TODO use virtual list because there might be many results
 
-export const handleInput = async (state, value) => {
+export const handleInput = (state, value) => {
   return setValue(state, value)
 }
 
-export const handleClick = async (state, index) => {
+const getFileIndex = (items, index) => {
+  console.log({ items })
+  for (let i = index; i >= 0; i--) {
+    const item = items[i]
+    if (item.type === SearchResultType.File) {
+      return i
+    }
+  }
+  return -1
+}
+
+const selectIndexFile = async (state, index) => {
+  const searchResult = state.items[index]
+  const path = searchResult.title
+  Assert.string(path)
+  await Command.execute(/* Main.openUri */ 'Main.openUri', /* uri */ path)
+  return state
+}
+
+const selectIndexPreview = async (state, index) => {
+  const fileIndex = getFileIndex(state.items, index)
+  if (fileIndex === -1) {
+    throw new Error('Search result is missing file')
+  }
+  const searchResult = state.items[fileIndex]
+  const path = searchResult.title
+  Assert.string(path)
+  await Command.execute(/* Main.openUri */ 'Main.openUri', /* uri */ path)
+  return state
+}
+
+export const selectIndex = async (state, index) => {
   const searchResult = state.items[index]
-  console.log({ searchResult })
+  switch (searchResult.type) {
+    case SearchResultType.File:
+      return selectIndexFile(state, index)
+    case SearchResultType.Preview:
+      return selectIndexPreview(state, index)
+    default:
+      throw new Error(`unexpected search result type ${searchResult.type}`)
+  }
+}
+
+export const handleContextMenuMouseAt = async (state, x, y) => {
+  const index = 1
   await Command.execute(
-    /* Main.openUri */ 'Main.openUri',
-    /* uri */ searchResult.path
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'search'
   )
   return state
 }
 
+export const handleContextMenuKeyboard = async (state) => {
+  const index = 1
+  const x = state.left // TODO
+  const y = state.top // TODO
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'search'
+  )
+  return state
+}
+
+export const handleClick = async (state, index) => {
+  return selectIndex(state, index)
+}
+
 export const hasFunctionalResize = true
 
 export const resize = (state, dimensions) => {

package/static/{d4a8cd1 → 56d97e9}/packages/renderer-worker/src/parts/WebStorage/WebStorage.js

@@ -1,11 +1,6 @@
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Json from '../Json/Json.js'
 
-export const StorageType = {
-  LocalStorage: 1,
-  SessionStorage: 2,
-}
-
 export const clear = async (storageType) => {
   await RendererProcess.invoke(
     /* StorageBrowser.clear */ 'StorageBrowser.clear',

package/static/56d97e9/packages/renderer-worker/src/parts/WebStorageType/WebStorageType.js

@@ -0,0 +1,3 @@
+export const LocalStorage = 1
+
+export const SessionStorage = 2

package/static/56d97e9/packages/renderer-worker/src/parts/Window/Window.js

@@ -0,0 +1,151 @@
+import * as ElectronApp from '../ElectronApp/ElectronApp.js'
+import * as ElectronWindow from '../ElectronWindow/ElectronWindow.js'
+import * as Platform from '../Platform/Platform.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+const reloadWeb = async () => {
+  await RendererProcess.invoke(/* windowReload */ 8080)
+}
+
+const reloadRemote = async () => {
+  await RendererProcess.invoke(/* windowReload */ 8080)
+}
+
+const reloadElectron = async () => {
+  await ElectronWindow.reload()
+}
+export const reload = () => {
+  switch (Platform.platform) {
+    case 'web':
+      return reloadWeb()
+    case 'remote':
+      return reloadRemote()
+    case 'electron':
+      return reloadElectron()
+    default:
+      return
+  }
+}
+
+const minimizeWeb = () => {}
+
+const minimizeRemote = () => {}
+
+const minimizeElectron = () => {
+  return ElectronWindow.minimize()
+}
+
+export const minimize = async () => {
+  switch (Platform.platform) {
+    case 'web':
+      return minimizeWeb()
+    case 'remote':
+      return minimizeRemote()
+    case 'electron':
+      return minimizeElectron()
+    default:
+      return
+  }
+}
+
+const maximizeWeb = () => {}
+const maximizeRemote = () => {}
+const maximizeElectron = () => {
+  return ElectronWindow.maximize()
+}
+
+export const maximize = async () => {
+  switch (Platform.platform) {
+    case 'web':
+      return maximizeWeb()
+    case 'remote':
+      return maximizeRemote()
+    case 'electron':
+      return maximizeElectron()
+    default:
+      return
+  }
+}
+
+const unmaximizeWeb = () => {}
+
+const unmaximizeRemote = () => {}
+
+const unmaximizeElectron = () => {
+  return ElectronWindow.unmaximize()
+}
+
+export const unmaximize = async () => {
+  switch (Platform.platform) {
+    case 'web':
+      return unmaximizeWeb()
+    case 'remote':
+      return unmaximizeRemote()
+    case 'electron':
+      return unmaximizeElectron()
+    default:
+      return
+  }
+}
+
+const closeWeb = () => {}
+const closeRemote = () => {}
+const closeElectron = () => {
+  return ElectronWindow.close()
+}
+
+export const close = async () => {
+  switch (Platform.platform) {
+    case 'web':
+      return closeWeb()
+    case 'remote':
+      return closeRemote()
+    case 'electron':
+      return closeElectron()
+    default:
+      return
+  }
+}
+
+const exitWeb = () => {}
+const exitRemote = () => {}
+const exitElectron = () => {
+  return ElectronApp.exit()
+}
+
+export const exit = () => {
+  switch (Platform.platform) {
+    case 'web':
+      return exitWeb()
+    case 'remote':
+      return exitRemote()
+    case 'electron':
+      return exitElectron()
+  }
+}
+
+export const setTitle = async (title) => {
+  await RendererProcess.invoke(
+    /* Window.setTitle */ 'Window.setTitle',
+    /* title */ title
+  )
+}
+
+const openNewWeb = () => {}
+const openNewRemote = () => {}
+const openNewElectron = () => {
+  return ElectronWindow.openNew()
+}
+
+export const openNew = async () => {
+  switch (Platform.platform) {
+    case 'web':
+      return openNewWeb()
+    case 'remote':
+      return openNewRemote()
+    case 'electron':
+      return openNewElectron()
+    default:
+      return
+  }
+}