@lvce-editor/server 0.0.30 → 0.0.33

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

@@ -1,8 +1,7 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
 import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
+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'
 // TODO send open signal to renderer process before items are ready
 // that way user can already type while items are still loading
@@ -31,7 +30,7 @@ export const create = (id, uri, top, left, width, height) => {
   return {
     state: QuickPickState.Default,
     picks: [],
-    filteredPicks: [],
+    items: [],
     recentPicks: [],
     recentPickIds: new Map(), // TODO use object.create(null) instead
     versionId: 0,
@@ -44,6 +43,9 @@ export const create = (id, uri, top, left, width, height) => {
     maxVisibleItems: 10,
     uri,
     cursorOffset: 0,
+    deltaY: 0,
+    itemHeight: 22,
+    height: 300,
   }
 }
 
@@ -66,7 +68,7 @@ const filterPicks = (state, picks, exclude, value) => {
     }
     // TODO also filtering for aliases might be expensive
     // TODO maybe only filter for aliases if prefix is longer than 4-5 characters
-    // otherwise both will be found anyway
+    // otherwise both will be found anywayf
     // e.g. "Relo" matches  "Window Reload"  and "Reload Window"
     // But "Reload Win" only matches "Reload Window"
     if (pick.aliases) {
@@ -78,39 +80,35 @@ const filterPicks = (state, picks, exclude, value) => {
     }
     return false
   }
-  const filteredPicks = picks.filter(filterPick)
-  return filteredPicks
-}
-
-const slicePicks = (filteredPicks) => {
-  return filteredPicks.slice(0, 10)
-}
-
-const toDisplayPicks = (picks) => {
-  const toDisplayPick = (pick, index) => {
-    return {
-      label: pick.label,
-      posInSet: index + 1,
-      setSize: picks.length,
-    }
+  const items = picks.filter(filterPick)
+  return items
+}
+
+const getVisible = (items, minLineY, maxLineY) => {
+  const visibleItems = []
+  const setSize = items.length
+  const max = Math.min(items.length, maxLineY)
+  for (let i = minLineY; i < max; i++) {
+    const item = items[i]
+    visibleItems.push({
+      label: item.label,
+      posInSet: i + 1,
+      setSize,
+    })
   }
-  return picks.map(toDisplayPick)
+  return visibleItems
 }
 
-const getVisiblePicks = (state, picks, filterValue) => {
+const getFilteredItems = (state, picks, filterValue) => {
   Assert.object(state)
   Assert.array(picks)
   Assert.string(filterValue)
-  const filteredPicks = filterPicks(
-    state,
-    picks,
-    state.recentPickIds,
-    filterValue
-  )
+  const items = filterPicks(state, picks, state.recentPickIds, filterValue)
+  return items
   // TODO avoid mutation
-  state.filteredPicks = filteredPicks
-  const slicedPicks = slicePicks(filteredPicks)
-  return toDisplayPicks(slicedPicks)
+  // state.items = items
+  // const slicedPicks = slicePicks(items)
+  // return toDisplayPicks(slicedPicks)
 }
 
 const getProvider = (uri) => {
@@ -167,7 +165,7 @@ export const loadContent = async (state) => {
     return
   }
   const filterValue = provider.getFilterValue(value)
-  const visiblePicks = getVisiblePicks(state, newPicks, filterValue)
+  const items = getFilteredItems(state, newPicks, filterValue)
   const placeholder = provider.getPlaceholder()
   const label = provider.getLabel()
   const minLineY = 0
@@ -178,12 +176,13 @@ export const loadContent = async (state) => {
   return {
     ...state,
     picks: newPicks,
-    visiblePicks,
+    items,
     focusedIndex: 0,
     state: QuickPickState.Finished,
     minLineY,
     maxLineY,
     value,
+    cursorOffset: value.length,
   }
 }
 
@@ -194,6 +193,7 @@ export const dispose = (state) => {
 }
 
 export const handleBlur = async (state) => {
+  console.log('quickpick blur')
   await Viewlet.closeWidget('QuickPick')
   return state
 }
@@ -205,15 +205,20 @@ const getPick = (state, index) => {
   //   return state.recentPicks[index]
   // }
   // index -= state.recentPicks.length
-  if (index < state.filteredPicks.length) {
-    return state.filteredPicks[index]
+  if (index < state.items.length) {
+    return state.items[index]
   }
   console.warn('no pick matching index', index)
 }
 
 export const selectIndex = async (state, index, button = /* left */ 0) => {
-  const pick = getPick(state, index)
-  const selectPickResult = await state.provider.selectPick(pick, index, button)
+  const actualIndex = index + state.minLineY
+  const pick = getPick(state, actualIndex)
+  const selectPickResult = await state.provider.selectPick(
+    pick,
+    actualIndex,
+    button
+  )
   Assert.object(selectPickResult)
   Assert.string(selectPickResult.command)
   const { command } = selectPickResult
@@ -236,8 +241,8 @@ export const selectIndex = async (state, index, button = /* left */ 0) => {
   // }
 }
 
-export const selectCurrentIndex = async (state) => {
-  await selectIndex(state, state.focusedIndex)
+export const selectCurrentIndex = (state) => {
+  return selectIndex(state, state.focusedIndex)
 }
 
 // TODO when user types letters -> no need to query provider again -> just filter existing results
@@ -247,13 +252,14 @@ export const handleInput = async (state, value, cursorOffset) => {
   }
   const newPicks = await state.provider.getPicks(value)
   const filterValue = state.provider.getFilterValue(value)
-  const visiblePicks = getVisiblePicks(state, newPicks, filterValue)
+  const items = getFilteredItems(state, newPicks, filterValue)
+  const focusedIndex = items.length === 0 ? -1 : 0
   return {
     ...state,
     value,
     picks: newPicks,
-    visiblePicks,
-    focusedIndex: 0,
+    items,
+    focusedIndex,
     cursorOffset,
   }
 }
@@ -433,27 +439,19 @@ export const focusIndex = async (state, index) => {
   // @ts-ignore
   if (state.provider.focusPick) {
     // @ts-ignore
-    await state.provider.focusPick(state.filteredPicks[index])
+    await state.provider.focusPick(state.items[index])
   }
   if (index < state.minLineY) {
     const minLineY = index
     const maxLineY = Math.min(
       index + state.maxVisibleItems,
-      state.filteredPicks.length - 1
-    )
-    const slicedPicks = state.filteredPicks.slice(
-      state.minLineY,
-      state.maxLineY
+      state.items.length - 1
     )
-    const displayPicks = toDisplayPicks(slicedPicks)
-    const relativeFocusIndex = index - state.minLineY
-    const relativeUnFocusIndex = state.focusedIndex - state.minLineY
     // TODO need to scroll up
     return {
       ...state,
       minLineY,
       maxLineY,
-      displayPicks,
       focusedIndex: index,
     }
   }
@@ -462,18 +460,10 @@ export const focusIndex = async (state, index) => {
     const minLineY = Math.max(0, index - state.maxVisibleItems)
     const maxLineY = Math.min(
       index + state.maxVisibleItems - 1,
-      state.filteredPicks.length - 1
+      state.items.length - 1
     )
-    const slicedPicks = state.filteredPicks.slice(
-      state.minLineY,
-      state.maxLineY
-    )
-    const displayPicks = toDisplayPicks(slicedPicks)
-    const relativeFocusIndex = index - state.minLineY
-    const relativeUnFocusIndex = state.focusedIndex - state.minLineY
     return {
       ...state,
-      displayPicks,
       minLineY,
       maxLineY,
       focusedIndex: index,
@@ -490,22 +480,51 @@ export const focusFirst = (state) => {
 }
 
 export const focusLast = (state) => {
-  return focusIndex(state, state.filteredPicks.length - 1)
+  return focusIndex(state, state.items.length - 1)
 }
 
 export const focusPrevious = (state) => {
   const previousIndex =
-    state.focusedIndex === 0
-      ? state.filteredPicks.length - 1
-      : state.focusedIndex - 1
+    state.focusedIndex === 0 ? state.items.length - 1 : state.focusedIndex - 1
   return focusIndex(state, previousIndex)
 }
 
 export const focusNext = (state) => {
-  const nextIndex = (state.focusedIndex + 1) % state.filteredPicks.length
+  const nextIndex = (state.focusedIndex + 1) % state.items.length
   return focusIndex(state, nextIndex)
 }
 
+export const setDeltaY = (state, deltaY) => {
+  Assert.object(state)
+  Assert.number(deltaY)
+  const { itemHeight, items, height } = state
+  const itemsLength = items.length
+  if (deltaY < 0) {
+    deltaY = 0
+  } else if (deltaY > itemsLength * itemHeight - height) {
+    deltaY = Math.max(itemsLength * itemHeight - height, 0)
+  }
+  if (state.deltaY === deltaY) {
+    return state
+  }
+  const minLineY = Math.round(deltaY / itemHeight)
+  const maxLineY = minLineY + Math.round(height / itemHeight)
+  Assert.number(minLineY)
+  Assert.number(maxLineY)
+  return {
+    ...state,
+    deltaY,
+    minLineY,
+    maxLineY,
+  }
+}
+
+export const handleWheel = (state, deltaY) => {
+  Assert.object(state)
+  Assert.number(deltaY)
+  return setDeltaY(state, state.deltaY + deltaY)
+}
+
 export const hasFunctionalRender = true
 
 const renderValue = {
@@ -539,15 +558,30 @@ const renderCursorOffset = {
 
 const renderItems = {
   isEqual(oldState, newState) {
-    return oldState.visiblePicks === newState.visiblePicks
+    return (
+      oldState.items === newState.items &&
+      oldState.minLineY === newState.minLineY &&
+      oldState.maxLineY === newState.maxLineY
+    )
   },
   apply(oldState, newState) {
-    // TODO compute visible picks here from filteredPicks and minLineY / maxLineY, maybe also do filtering here
+    if (newState.items.length === 0) {
+      return [
+        /* Viewlet.send */ 'Viewlet.send',
+        /* id */ 'QuickPick',
+        /* method */ 'showNoResults',
+      ]
+    }
+    const visibleItems = getVisible(
+      newState.items,
+      newState.minLineY,
+      newState.maxLineY
+    )
     return [
       /* Viewlet.send */ 'Viewlet.send',
       /* id */ 'QuickPick',
       /* method */ 'setVisiblePicks',
-      /* visiblePicks */ newState.visiblePicks,
+      /* visiblePicks */ visibleItems,
     ]
   },
 }
@@ -568,8 +602,8 @@ const renderFocusedIndex = {
 }
 
 export const render = [
-  renderFocusedIndex,
-  renderCursorOffset,
   renderItems,
   renderValue,
+  renderCursorOffset,
+  renderFocusedIndex,
 ]

package/static/b576f0e/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.ipc.js

@@ -0,0 +1,11 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletSearch from './ViewletSearch.js'
+
+// prettier-ignore
+export const Commands = {
+  'Search.handleInput': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleInput),
+  'Search.handleClick': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleClick),
+  'Search.setValue': Viewlet.wrapViewletCommand('Search', ViewletSearch.setValue),
+}
+
+export * from './ViewletSearch.js'

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

@@ -1,6 +1,7 @@
-import * as SharedProcess from '../SharedProcess/SharedProcess.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Command from '../Command/Command.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as TextSearch from '../TextSearch/TextSearch.js'
 import * as Workspace from '../Workspace/Workspace.js'
 
 // TODO maybe create should have a container as param like vscode?
@@ -38,15 +39,58 @@ export const loadContent = async (state) => {
 
 export const contentLoaded = async () => {}
 
-export const setValue = (state, value) => {
-  state.value = value
+const getStatusMessage = (resultCount, fileResultCount) => {
+  if (resultCount === 0) {
+    return 'No results found'
+  }
+  if (resultCount === 1 && fileResultCount === 1) {
+    return 'Found 1 result in 1 file'
+  }
+  if (fileResultCount === 1) {
+    return `Found ${resultCount} results in 1 file`
+  }
+  return `Found ${resultCount} results in ${fileResultCount} files`
+}
+
+const getResultCounts = (results) => {
+  let resultCount = 0
+  for (const result of results) {
+    resultCount += result.length - 1
+  }
+  return resultCount
+}
+
+// TODO
+export const setValue = async (state, value) => {
+  // state.value = value
   // TODO use Id module
-  state.searchId = Math.random()
-  SharedProcess.send(
-    /* Search.search */ 907771,
-    /* id */ state.id,
-    /* searchId */ state.searchId
-  )
+  // state.searchId = Math.random()
+  // SharedProcess.send(
+  //   /* Search.search */ 907771,
+  //   /* id */ state.id,
+  //   /* searchId */ state.searchId
+  // )
+  // TODO
+  try {
+    const root = Workspace.state.workspacePath
+    const results = await TextSearch.textSearch(root, value)
+    const displayResults = toDisplayResults(results)
+    const resultCount = getResultCounts(results)
+    const fileResultCount = results.length
+    const message = getStatusMessage(resultCount, fileResultCount)
+    return {
+      ...state,
+      value,
+      items: displayResults,
+      message,
+    }
+  } catch (error) {
+    return {
+      ...state,
+      message: `${error}`,
+      value,
+    }
+  }
 }
 
 export const handleResult = async (state, result) => {
@@ -99,41 +143,28 @@ const toDisplayResults = (results) => {
   }
   return displayResults
 }
+// TODO implement virtual list, only send visible items to renderer process
 
-export const handleInput = async (state, value) => {
-  // TODO support streaming results
-  // TODO support cancellation
-  // TODO handle error
-  // TODO use command.execute or use module directly?
-  const results = await Command.execute(
-    /* FindInWorkspace.findInWorkspace */ 5200,
-    /* searchTerm */ value
-  )
-  // TODO send results to renderer process
-  // TODO use virtual list because there might be many results
-  console.log({
-    value,
-    results,
-  })
-
-  // TODO implement virtual list, only send visible items to renderer process
+// TODO maybe rename to result.items and result.stats
+// TODO support streaming results
+// TODO support cancellation
+// TODO handle error
+// TODO use command.execute or use module directly?
+// TODO send results to renderer process
+// TODO use virtual list because there might be many results
 
-  // TODO maybe rename to result.items and result.stats
-  const displayResults = toDisplayResults(results.results)
-  return {
-    ...state,
-    searchResults: displayResults,
-    fileCount: results.results.length, // TODO this is weird
-  }
+export const handleInput = async (state, value) => {
+  return setValue(state, value)
 }
 
 export const handleClick = async (state, index) => {
-  const searchResult = state.searchResults[index]
+  const searchResult = state.items[index]
   console.log({ searchResult })
   await Command.execute(
     /* Main.openUri */ 'Main.openUri',
     /* uri */ searchResult.path
   )
+  return state
 }
 
 export const hasFunctionalResize = true
@@ -147,20 +178,34 @@ export const resize = (state, dimensions) => {
 
 export const hasFunctionalRender = true
 
-const renderResults = {
+const renderItems = {
   isEqual(oldState, newState) {
-    return oldState.searchResults === newState.searchResults
+    return oldState.items === newState.items
   },
   apply(oldState, newState) {
     return [
       /* viewletSend */ 'Viewlet.send',
       /* id */ 'Search',
       /* method */ 'setResults',
-      /* results */ newState.searchResults,
-      /* resultCount */ newState.searchResults.length,
+      /* results */ newState.items,
+      /* resultCount */ newState.items.length,
       /* fileCount */ newState.fileCount,
     ]
   },
 }
 
-export const render = [renderResults]
+const renderMessage = {
+  isEqual(oldState, newState) {
+    return oldState.message === newState.message
+  },
+  apply(oldState, newState) {
+    return [
+      /* viewletSend */ 'Viewlet.send',
+      /* id */ 'Search',
+      /* method */ 'setMessage',
+      /* message */ newState.message,
+    ]
+  },
+}
+
+export const render = [renderItems, renderMessage]

package/static/{56ac02a → b576f0e}/packages/renderer-worker/src/parts/ViewletStates/ViewletStates.js

@@ -15,6 +15,10 @@ export const getInstance = (key) => {
   return state.instances[key]
 }
 
+export const hasInstance = (key) => {
+  return key in state.instances
+}
+
 export const remove = (key) => {
   delete state.instances[key]
 }

package/static/{56ac02a → b576f0e}/packages/renderer-worker/src/parts/Workbench/Workbench.js

@@ -16,6 +16,7 @@ import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as SessionReplay from '../SessionReplay/SessionReplay.js'
 import * as InitData from '../InitData/InitData.js'
 import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
 
 const handleUnhandledRejection = async (event) => {
   console.info(`[renderer-worker] Unhandled Rejection: ${event.reason}`)
@@ -140,8 +141,9 @@ export const startup = async (config) => {
   LifeCycle.mark(LifeCycle.Phase.Fifteen)
 
   if (Workspace.isTest()) {
+    const testPath = await Platform.getTestPath()
     const jsPath = initData.Location.href
-      .replace('/tests', '/packages/extension-host-worker-tests/src')
+      .replace('/tests', `${testPath}/src`)
       .replace(/\.html$/, '.js')
     await Command.execute('Test.execute', jsPath)
   } else {