@lvce-editor/server 0.7.2 → 0.7.4

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.ipc.js

@@ -0,0 +1,45 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletExtensions from './ViewletExtensions.js'
+import * as LazyCommand from '../LazyCommand/LazyCommand.js'
+
+const Imports = {
+  FocusFirst: () => import('./ViewletExtensionsFocusFirst.js'),
+  FocusIndex: () => import('./ViewletExtensionsFocusIndex.js'),
+  FocusLast: () => import('./ViewletExtensionsFocusLast.js'),
+  FocusNext: () => import('./ViewletExtensionsFocusNext.js'),
+  FocusNextPage: () => import('./ViewletExtensionsFocusNextPage.js'),
+  FocusPrevious: () => import('./ViewletExtensionsFocusPrevious.js'),
+  FocusPreviousPage: () => import('./ViewletExtensionsFocusPreviousPage.js'),
+  HandleClick: () => import('./ViewletExtensionsHandleClick.js'),
+  HandleTouchStart: () => import('./ViewletExtensionsHandleTouchStart.js'),
+  HandleTouchEnd: () => import('./ViewletExtensionsHandleTouchEnd.js'),
+  HandleTouchMove: () => import('./ViewletExtensionsHandleTouchMove.js'),
+}
+
+// prettier-ignore
+export const Commands = {
+  'Extensions.closeSuggest': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.closeSuggest),
+  'Extensions.focusFirst': LazyCommand.create(ViewletExtensions.name, Imports.FocusFirst, 'focusFirst'),
+  'Extensions.focusIndex': LazyCommand.create(ViewletExtensions.name, Imports.FocusIndex, 'focusIndex'),
+  'Extensions.focusLast': LazyCommand.create(ViewletExtensions.name, Imports.FocusLast, 'focusLast'),
+  'Extensions.focusNext': LazyCommand.create(ViewletExtensions.name, Imports.FocusNext, 'focusNext'),
+  'Extensions.focusNextPage': LazyCommand.create(ViewletExtensions.name, Imports.FocusNextPage, 'focusNextPage'),
+  'Extensions.focusPrevious': LazyCommand.create(ViewletExtensions.name, Imports.FocusPrevious, 'focusPrevious'),
+  'Extensions.focusPreviousPage': LazyCommand.create(Imports.FocusPreviousPage, 'focusPreviousPage'),
+  'Extensions.handleClick': LazyCommand.create(ViewletExtensions.name, Imports.HandleClick, 'handleClick'),
+  'Extensions.handleContextMenu': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleContextMenu),
+  'Extensions.handleInput': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleInput),
+  'Extensions.handleInstall': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleInstall),
+  'Extensions.handleScrollBarClick': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleScrollBarClick),
+  'Extensions.handleScrollBarMove': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleScrollBarMove),
+  'Extensions.handleTouchEnd':LazyCommand.create(ViewletExtensions.name, Imports.HandleTouchEnd, 'handleTouchEnd'),
+  'Extensions.handleTouchMove':LazyCommand.create(ViewletExtensions.name, Imports.HandleTouchMove, 'handleTouchMove'),
+  'Extensions.handleTouchStart': LazyCommand.create(ViewletExtensions.name, Imports.HandleTouchStart, 'handleTouchStart'),
+  'Extensions.handleUninstall': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleUninstall),
+  'Extensions.handleWheel': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.handleWheel),
+  'Extensions.openSuggest': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.openSuggest),
+  'Extensions.setDeltaY': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.setDeltaY),
+  'Extensions.toggleSuggest': Viewlet.wrapViewletCommand(ViewletExtensions.name, ViewletExtensions.toggleSuggest),
+}
+
+export * from './ViewletExtensions.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.js

@@ -9,7 +9,6 @@ import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import {
   getListHeight,
   HEADER_HEIGHT,
-  ITEM_HEIGHT,
   MINIMUM_SLIDER_SIZE,
 } from './ViewletExtensionsShared.js'
 
@@ -55,6 +54,7 @@ export const create = (id, uri, left, top, width, height) => {
     touchOffsetY: 0,
     touchTimeStamp: 0,
     touchDifference: 0,
+    itemHeight: 62,
   }
 }
 
@@ -63,6 +63,7 @@ const getVisible = (state) => {
 }
 
 export const loadContent = async (state) => {
+  const { itemHeight, height } = state
   // TODO just get local extensions on demand (not when query string is already different)
 
   // TODO get installed extensions from extension host
@@ -70,18 +71,19 @@ export const loadContent = async (state) => {
   const extensions = await ExtensionManagement.getAllExtensions()
   const viewObjects = filterExtensions(
     extensions.map(toInstalledViewObject),
-    state.parsedValue
+    state.parsedValue,
+    itemHeight
   )
 
   const listHeight = getListHeight(state)
-  const contentHeight = viewObjects.length * ITEM_HEIGHT
-  const scrollBarHeight = getScrollBarHeight(state.height, contentHeight)
+  const contentHeight = viewObjects.length * itemHeight
+  const scrollBarHeight = getScrollBarHeight(height, contentHeight)
 
   return {
     ...state,
     extensions,
     filteredExtensions: viewObjects,
-    maxLineY: Math.round(listHeight / ITEM_HEIGHT),
+    maxLineY: Math.round(listHeight / itemHeight),
     scrollBarHeight,
   }
 }
@@ -191,7 +193,7 @@ const matchesParsedValue = (extension, parsedValue) => {
   return false
 }
 
-const filterExtensions = (extensions, parsedValue) => {
+const filterExtensions = (extensions, parsedValue, itemHeight) => {
   const filteredExtensions = []
   for (const extension of extensions) {
     if (matchesParsedValue(extension, parsedValue)) {
@@ -202,7 +204,7 @@ const filterExtensions = (extensions, parsedValue) => {
   for (let i = 0; i < filteredExtensions.length; i++) {
     filteredExtensions[i].setSize = filteredExtensions.length
     filteredExtensions[i].posInSet = i + 1
-    filteredExtensions[i].top = i * ITEM_HEIGHT
+    filteredExtensions[i].top = i * itemHeight
   }
   return filteredExtensions
 }
@@ -252,6 +254,7 @@ export const handleInput = async (state, value) => {
   try {
     // TODO make this functional somehow
     state.searchValue = value
+    const { itemHeight } = state
     // TODO cancel ongoing requests
     // TODO handle errors
     const parsedValue = parseValue(value)
@@ -264,7 +267,11 @@ export const handleInput = async (state, value) => {
     if (state.searchValue !== value) {
       return state
     }
-    const filteredExtensions = filterExtensions(extensions, parsedValue)
+    const filteredExtensions = filterExtensions(
+      extensions,
+      parsedValue,
+      itemHeight
+    )
     const displayExtensions = toDisplayExtensions(filteredExtensions)
     return {
       ...state,
@@ -444,9 +451,10 @@ export const toggleSuggest = async (state) => {
 export const hasFunctionalResize = true
 
 export const resize = (state, dimensions) => {
+  const { itemHeight, minLineY } = state
   // TODO should just return new state, render function can take old state and new state and return render commands
   const listHeight = getListHeight(dimensions)
-  const maxLineY = state.minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
+  const maxLineY = minLineY + Math.ceil(listHeight / itemHeight)
   return {
     ...state,
     ...dimensions,
@@ -458,23 +466,18 @@ export const setDeltaY = (state, deltaY) => {
   Assert.object(state)
   Assert.number(deltaY)
   const listHeight = getListHeight(state)
+  const { itemHeight, filteredExtensions } = state
   if (deltaY < 0) {
     deltaY = 0
-  } else if (
-    deltaY >
-    state.filteredExtensions.length * ITEM_HEIGHT - listHeight
-  ) {
-    deltaY = Math.max(
-      state.filteredExtensions.length * ITEM_HEIGHT - listHeight,
-      0
-    )
+  } else if (deltaY > filteredExtensions.length * itemHeight - listHeight) {
+    deltaY = Math.max(filteredExtensions.length * itemHeight - listHeight, 0)
   }
   if (state.deltaY === deltaY) {
     return state
   }
   // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
-  const minLineY = Math.floor(deltaY / ITEM_HEIGHT)
-  const maxLineY = minLineY + Math.round(listHeight / ITEM_HEIGHT)
+  const minLineY = Math.floor(deltaY / itemHeight)
+  const maxLineY = minLineY + Math.round(listHeight / itemHeight)
   const negativeMargin = -Math.round(deltaY)
   return {
     ...state,
@@ -571,7 +574,8 @@ const renderHeight = {
     )
   },
   apply(oldState, newState) {
-    const contentHeight = newState.filteredExtensions.length * ITEM_HEIGHT
+    const { itemHeight } = newState
+    const contentHeight = newState.filteredExtensions.length * itemHeight
     return [
       /* Viewlet.send */ 'Viewlet.send',
       /* id */ 'Extensions',

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusIndex.js

@@ -1,6 +1,7 @@
-import { getListHeight, ITEM_HEIGHT } from './ViewletExtensionsShared.js'
+import { getListHeight } from './ViewletExtensionsShared.js'
 
 export const focusIndex = (state, index) => {
+  const { itemHeight } = state
   if (index === -1) {
     return {
       ...state,
@@ -11,8 +12,8 @@ export const focusIndex = (state, index) => {
   if (index < state.minLineY + 1) {
     // scroll up
     const minLineY = index
-    const maxLineY = minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
-    const negativeMargin = -minLineY * ITEM_HEIGHT
+    const maxLineY = minLineY + Math.ceil(listHeight / itemHeight)
+    const negativeMargin = -minLineY * itemHeight
     return {
       ...state,
       focusedIndex: index,
@@ -24,9 +25,9 @@ export const focusIndex = (state, index) => {
   if (index >= state.maxLineY - 1) {
     //  scroll down
     const maxLineY = index + 1
-    const minLineY = maxLineY - Math.ceil(listHeight / ITEM_HEIGHT)
+    const minLineY = maxLineY - Math.ceil(listHeight / itemHeight)
     const negativeMargin =
-      -minLineY * ITEM_HEIGHT + (listHeight % ITEM_HEIGHT) - ITEM_HEIGHT
+      -minLineY * itemHeight + (listHeight % itemHeight) - itemHeight
     return {
       ...state,
       focusedIndex: index,

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsShared.js

@@ -1,5 +1,3 @@
-export const ITEM_HEIGHT = 62
-
 export const MINIMUM_SLIDER_SIZE = 20
 
 export const HEADER_HEIGHT = 35.94 // TODO improve this

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletKeyBindings/ViewletKeyBindings.ipc.js

@@ -0,0 +1,10 @@
+import * as ViewletKeyBindings from './ViewletKeyBindings.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'KeyBindings.handleInput': Viewlet.wrapViewletCommand(ViewletKeyBindings.name, ViewletKeyBindings.handleInput),
+  'KeyBindings.handleWheel': Viewlet.wrapViewletCommand(ViewletKeyBindings.name, ViewletKeyBindings.handleWheel),
+}
+
+export * from './ViewletKeyBindings.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletKeyBindings/ViewletKeyBindingsRender.js

@@ -216,4 +216,21 @@ const renderValue = {
   },
 }
 
-export const render = [renderKeyBindings, renderValue]
+const renderNoResults = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.value === newState.value &&
+      newState.filteredKeyBindings.length === 0
+    )
+  },
+  apply(oldState, newState) {
+    const message =
+      newState.filteredKeyBindings.length === 0 ? 'No Results found' : ''
+    return [
+      /* Viewlet.ariaAnnounce */ 'Viewlet.ariaAnnounce',
+      /* message */ message,
+    ]
+  },
+}
+
+export const render = [renderKeyBindings, renderValue, renderNoResults]

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletLocations/ViewletLocations.ipc.js

@@ -0,0 +1,13 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletLocations from './ViewletLocations.js'
+
+// prettier-ignore
+export const Commands = {
+  'Locations.focusFirst': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.focusFirst),
+  'Locations.focusIndex': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.focusIndex),
+  'Locations.focusLast': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.focusLast),
+  'Locations.focusNext': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.focusNext),
+  'Locations.focusPrevious': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.focusPrevious),
+  'Locations.selectCurrent': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.selectCurrent),
+  'Locations.selectIndex': Viewlet.wrapViewletCommand(ViewletLocations.name, ViewletLocations.selectIndex),
+}

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.ipc.js

@@ -0,0 +1,25 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletMain from './ViewletMain.js'
+
+// prettier-ignore
+export const Commands = {
+  'Main.closeActiveEditor': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeActiveEditor),
+  'Main.closeAllEditors': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeAllEditors),
+  'Main.closeEditor': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeEditor),
+  'Main.closeFocusedTab': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeFocusedTab),
+  'Main.closeOthers': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeOthers),
+  'Main.closeTabsLeft': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeTabsLeft),
+  'Main.closeTabsRight': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.closeTabsRight),
+  'Main.focusFirst': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.focusFirst),
+  'Main.focusLast': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.focusLast),
+  'Main.focusNext': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.focusNext),
+  'Main.focusPrevious': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.focusPrevious),
+  'Main.handleDrop': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.handleDrop),
+  'Main.handleTabClick': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.handleTabClick),
+  'Main.handleTabContextMenu': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.handleTabContextMenu),
+  'Main.hydrate': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.hydrate),
+  'Main.openUri': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.openUri),
+  'Main.save': Viewlet.wrapViewletCommand(ViewletMain.name, ViewletMain.save),
+}
+
+export * from './ViewletMain.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -59,6 +59,19 @@ const getInstanceSavedState = (savedState, id) => {
   return undefined
 }
 
+const getRenderCommands = (module, oldState, newState) => {
+  if (Array.isArray(module.render)) {
+    const commands = []
+    for (const item of module.render) {
+      if (!item.isEqual(oldState, newState)) {
+        commands.push(item.apply(oldState, newState))
+      }
+    }
+    return commands
+  }
+  return module.render(oldState, newState)
+}
+
 // TODO add lots of unit tests for this
 /**
  *
@@ -119,6 +132,41 @@ export const load = async (viewlet, focus = false, restore = false) => {
       instanceSavedState = getInstanceSavedState(stateToSave, viewlet.id)
     }
     let newState = await module.loadContent(viewletState, instanceSavedState)
+
+    const extraCommands = []
+
+    if (module.getChildren) {
+      const children = module.getChildren(newState)
+      const childModules = await Promise.all(
+        children.map((child) => child.id).map(viewlet.getModule)
+      )
+
+      for (const childModule of childModules) {
+        await RendererProcess.invoke(
+          /* Viewlet.load */ 'Viewlet.loadModule',
+          /* id */ childModule.name
+        )
+        if (childModule.Commands) {
+          for (const [key, value] of Object.entries(childModule.Commands)) {
+            Command.register(key, value)
+          }
+        }
+      }
+
+      for (const childModule of childModules) {
+        const oldState = childModule.create()
+        const newState = await childModule.loadContent(oldState)
+        const childInstance = {
+          state: newState,
+          factory: childModule,
+        }
+        ViewletStates.set(childModule.name, childInstance)
+        const commands = getRenderCommands(childModule, oldState, newState)
+        extraCommands.push(['Viewlet.create', childModule.name])
+        extraCommands.push(...commands)
+        extraCommands.push(['Viewlet.append', viewlet.id, childModule.name])
+      }
+    }
     if (focus && module.focus) {
       newState = await module.focus(newState)
     }
@@ -175,20 +223,12 @@ export const load = async (viewlet, focus = false, restore = false) => {
     }
 
     if (module.hasFunctionalRender) {
-      let commands = []
-      if (Array.isArray(module.render)) {
-        for (const item of module.render) {
-          if (!item.isEqual(viewletState, newState)) {
-            commands.push(item.apply(viewletState, newState))
-          }
-        }
-      } else {
-        commands = module.render(viewletState, newState)
-      }
+      const commands = getRenderCommands(module, viewletState, newState)
       if (viewlet.show === false) {
         const allCommands = [
           ['Viewlet.create', viewlet.id],
           ...commands,
+          ...extraCommands,
           ['Viewlet.show', viewlet.id],
         ]
         if (module.getPosition) {
@@ -203,6 +243,8 @@ export const load = async (viewlet, focus = false, restore = false) => {
         }
         return allCommands
       }
+      // console.log('else', viewlet.id, { commands })
+      commands.push(...extraCommands)
       await RendererProcess.invoke(
         /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
         /* commands */ commands

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletModule/ViewletModule.js

@@ -56,6 +56,10 @@ export const load = (moduleId) => {
       return import('../ViewletEditorFindWidget/ViewletEditorFindWidget.ipc.js')
     case ViewletModuleId.ExtensionDetail:
       return import('../ViewletExtensionDetail/ViewletExtensionDetail.ipc.js')
+    case ViewletModuleId.TitleBarButtons:
+      return import('../ViewletTitleBarButtons/ViewletTitleBarButtons.ipc.js')
+    case ViewletModuleId.TitleBarMenuBar:
+      return import('../ViewletTitleBarMenuBar/ViewletTitleBarMenuBar.ipc.js')
     default:
       throw new Error(`unknown module "${moduleId}"`)
   }

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletModuleId/ViewletModuleId.js

@@ -51,3 +51,7 @@ export const TitleBar = 'TitleBar'
 export const EditorFindWidget = 'EditorFindWidget'
 
 export const ExtensionDetail = 'ExtensionDetail'
+
+export const TitleBarMenuBar = 'TitleBarMenuBar'
+
+export const TitleBarButtons = 'TitleBarButtons'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletPanel/ViewletPanel.ipc.js

@@ -3,7 +3,7 @@ import * as Viewlet from '../Viewlet/Viewlet.js'
 
 // prettier-ignore
 export const Commands = {
-  'Panel.selectIndex': Viewlet.wrapViewletCommand('Panel', ViewletPanel.selectIndex)
+  'Panel.selectIndex': Viewlet.wrapViewletCommand(ViewletPanel.name, ViewletPanel.selectIndex)
 }
 
 export * from './ViewletPanel.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletProblems/ViewletProblems.ipc.js

@@ -3,7 +3,7 @@ import * as ViewletProblems from './ViewletProblems.js'
 
 // prettier-ignore
 export const Commands = {
-  'ViewletProblems.focusIndex': Viewlet.wrapViewletCommand('Problems', ViewletProblems.focusIndex),
+  'ViewletProblems.focusIndex': Viewlet.wrapViewletCommand(ViewletProblems.name, ViewletProblems.focusIndex),
 }
 
 export * from './ViewletProblems.js'

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.ipc.js

@@ -0,0 +1,31 @@
+import * as ViewletQuickPick from './ViewletQuickPick.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as LazyCommand from '../LazyCommand/LazyCommand.js'
+
+// prettier-ignore
+const Imports = {
+  FocusFirst: () => import('./ViewletQuickPickFocusFirst.js'),
+  FocusIndex: () => import('./ViewletQuickPickFocusIndex.js'),
+  FocusLast: () => import('./ViewletQuickPickFocusLast.js'),
+  FocusNext: () => import('./ViewletQuickPickFocusNext.js'),
+  FocusPrevious: () => import('./ViewletQuickPickFocusPrevious.js'),
+}
+
+// prettier-ignore
+export const Commands = {
+  'QuickPick.focusFirst': LazyCommand.create(ViewletQuickPick.name, Imports.FocusFirst, 'focusFirst'),
+  'QuickPick.focusIndex': LazyCommand.create(ViewletQuickPick.name, Imports.FocusIndex, 'focusIndex'),
+  'QuickPick.focusLast': LazyCommand.create(ViewletQuickPick.name, Imports.FocusLast, 'focusLast'),
+  'QuickPick.focusNext': LazyCommand.create(ViewletQuickPick.name, Imports.FocusNext, 'focusNext'),
+  'QuickPick.focusPrevious': LazyCommand.create(ViewletQuickPick.name, Imports.FocusPrevious, 'focusPrevious'),
+  'QuickPick.handleBeforeInput': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.handleBeforeInput),
+  'QuickPick.handleBlur': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.handleBlur),
+  'QuickPick.handleInput': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.handleInput),
+  'QuickPick.handleWheel': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.handleWheel),
+  'QuickPick.selectCurrentIndex': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.selectCurrentIndex),
+  'QuickPick.selectIndex': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.selectIndex),
+  'QuickPick.selectItem': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.selectItem),
+  'QuickPick.handleClickAt': Viewlet.wrapViewletCommand(ViewletQuickPick.name, ViewletQuickPick.handleClickAt),
+}
+
+export * from './ViewletQuickPick.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -280,37 +280,6 @@ export const handleBeforeInput = (
 //
 // })
 
-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 handleClickAt = (state, x, y) => {
   const { top, headerHeight, itemHeight } = state
   const relativeY = y - top - headerHeight
@@ -439,3 +408,5 @@ export const render = [
   renderFocusedIndex,
   renderHeight,
 ]
+
+export * from '../VirtualList/VirtualList.js'

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

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

package/static/ce25a54/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.ipc.js

@@ -0,0 +1,12 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletSideBar from './ViewletSideBar.js'
+
+// prettier-ignore
+export const Commands =  {
+  'SideBar.focus': Viewlet.wrapViewletCommand(ViewletSideBar.name, ViewletSideBar.focus),
+  'SideBar.openViewlet': Viewlet.wrapViewletCommand(ViewletSideBar.name, ViewletSideBar.openViewlet),
+  'SideBar.show': Viewlet.wrapViewletCommand(ViewletSideBar.name, ViewletSideBar.openViewlet),
+  'SideBar.showOrHideViewlet': Viewlet.wrapViewletCommand(ViewletSideBar.name, ViewletSideBar.showOrHideViewlet),
+}
+
+export * from './ViewletSideBar.js'

package/static/{18087fa → ce25a54}/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.js

@@ -9,6 +9,8 @@ import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
 import * as LocalStorage from '../LocalStorage/LocalStorage.js'
 
+export const name = 'SideBar'
+
 export const create = (id, uri, left, top, width, height) => {
   return {
     currentViewletId: '',