@lvce-editor/server 0.2.2 → 0.4.1

package/static/{e2dcaea → b10f46d}/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBar.js

@@ -1,10 +1,9 @@
+import * as ActivityBarItemFlags from '../ActivityBarItemFlags/ActvityBarItemFlags.js'
 import * as Command from '../Command/Command.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Layout from '../Layout/Layout.js'
-import * as ViewletStates from '../ViewletStates/ViewletStates.js'
-import * as ActivityBarItemFlags from '../ActivityBarItemFlags/ActvityBarItemFlags.js'
 import * as I18nString from '../I18NString/I18NString.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 
 /**
  * @enum {string}
@@ -191,52 +190,6 @@ const findIndex = (activityBarItems, id) => {
   return -1
 }
 
-const handleClickSettings = async (state, x, y, viewletId) => {
-  console.log('is settings')
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ 'settings'
-  )
-  return state
-}
-
-const handleClickAdditionalViews = async (state, x, y, viewletId) => {
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ 'activity-bar-additional-views'
-  )
-  return state
-}
-
-const handleClickOther = async (state, x, y, viewletId) => {
-  if (Layout.isSideBarVisible()) {
-    await Command.execute(
-      /* SideBar.showOrHideViewlet */ 'SideBar.showOrHideViewlet',
-      /* id */ viewletId
-    )
-  } else {
-    // TODO should show side bar with viewletId
-    await Layout.showSideBar()
-  }
-  return state
-}
-
-export const handleClick = async (state, index, x, y) => {
-  const viewletId = state.activityBarItems[index].id
-  switch (viewletId) {
-    case 'Settings':
-      return handleClickSettings(state, x, y, viewletId)
-    case 'Additional Views':
-      return handleClickAdditionalViews(state, x, y, viewletId)
-    default:
-      return handleClickOther(state, x, y, viewletId)
-  }
-}
-
 export const handleSideBarViewletChange = async (state, id, ...args) => {
   const index = findIndex(state.activityBarItems, id)
   const oldIndex = state.selectedIndex
@@ -315,65 +268,6 @@ export const handleContextMenu = async (state, x, y) => {
   return state
 }
 
-export const focusIndex = (state, index) => {
-  return {
-    ...state,
-    focusedIndex: index,
-  }
-}
-
-export const focus = (state) => {
-  const indexToFocus = state.focusedIndex === -1 ? 0 : state.focusedIndex
-  return focusIndex(state, indexToFocus)
-}
-
-export const focusNext = (state) => {
-  // TODO can never be -1 -> always set when sidebar changes
-  if (state.focusedIndex === state.activityBarItems.length - 1) {
-    return state
-  }
-  return focusIndex(state, state.focusedIndex + 1)
-}
-
-export const focusPrevious = (state) => {
-  if (state.focusedIndex === 0) {
-    return state
-  }
-  return focusIndex(state, state.focusedIndex - 1)
-}
-
-export const focusFirst = (state) => {
-  return focusIndex(state, 0)
-}
-
-export const focusLast = (state) => {
-  return focusIndex(state, state.activityBarItems.length - 1)
-}
-
-const getPosition = (state, index) => {
-  const { activityBarItems, top, left, height, itemHeight } = state
-  if (index > activityBarItems.length - 2) {
-    // at bottom
-    return {
-      x: left,
-      y: top + height - (activityBarItems.length - 1 - index) * itemHeight,
-    }
-  }
-  // at top
-  return {
-    x: left,
-    y: top + index * itemHeight,
-  }
-}
-
-export const selectCurrent = async (state) => {
-  if (state.focusedIndex === -1) {
-    return
-  }
-  const position = getPosition(state, state.focusedIndex)
-  await handleClick(state, state.focusedIndex, position.x, position.y)
-}
-
 export const hasFunctionalResize = true
 
 export const resize = (state, dimensions) => {

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocus.js

@@ -0,0 +1,6 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+
+export const focus = (state) => {
+  const indexToFocus = state.focusedIndex === -1 ? 0 : state.focusedIndex
+  return focusIndex(state, indexToFocus)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusFirst.js

@@ -0,0 +1,5 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+
+export const focusFirst = (state) => {
+  return focusIndex(state, 0)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusIndex.js

@@ -0,0 +1,6 @@
+export const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusLast.js

@@ -0,0 +1,5 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+
+export const focusLast = (state) => {
+  return focusIndex(state, state.activityBarItems.length - 1)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusNext.js

@@ -0,0 +1,9 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+
+export const focusNext = (state) => {
+  // TODO can never be -1 -> always set when sidebar changes
+  if (state.focusedIndex === state.activityBarItems.length - 1) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex + 1)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusPrevious.js

@@ -0,0 +1,8 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+
+export const focusPrevious = (state) => {
+  if (state.focusedIndex === 0) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex - 1)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarHandleClick.js

@@ -0,0 +1,48 @@
+import * as Command from '../Command/Command.js'
+import * as Layout from '../Layout/Layout.js'
+
+const handleClickSettings = async (state, x, y, viewletId) => {
+  console.log('is settings')
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'settings'
+  )
+  return state
+}
+
+const handleClickAdditionalViews = async (state, x, y, viewletId) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'activity-bar-additional-views'
+  )
+  return state
+}
+
+const handleClickOther = async (state, x, y, viewletId) => {
+  if (Layout.isSideBarVisible()) {
+    await Command.execute(
+      /* SideBar.showOrHideViewlet */ 'SideBar.showOrHideViewlet',
+      /* id */ viewletId
+    )
+  } else {
+    // TODO should show side bar with viewletId
+    await Layout.showSideBar()
+  }
+  return state
+}
+
+export const handleClick = async (state, index, x, y) => {
+  const viewletId = state.activityBarItems[index].id
+  switch (viewletId) {
+    case 'Settings':
+      return handleClickSettings(state, x, y, viewletId)
+    case 'Additional Views':
+      return handleClickAdditionalViews(state, x, y, viewletId)
+    default:
+      return handleClickOther(state, x, y, viewletId)
+  }
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarSelectCurrent.js

@@ -0,0 +1,25 @@
+import { handleClick } from './ViewletActivityBarHandleClick.js'
+
+const getPosition = (state, index) => {
+  const { activityBarItems, top, left, height, itemHeight } = state
+  if (index > activityBarItems.length - 2) {
+    // at bottom
+    return {
+      x: left,
+      y: top + height - (activityBarItems.length - 1 - index) * itemHeight,
+    }
+  }
+  // at top
+  return {
+    x: left,
+    y: top + index * itemHeight,
+  }
+}
+
+export const selectCurrent = async (state) => {
+  if (state.focusedIndex === -1) {
+    return
+  }
+  const position = getPosition(state, state.focusedIndex)
+  await handleClick(state, state.focusedIndex, position.x, position.y)
+}

package/static/{e2dcaea → b10f46d}/packages/renderer-worker/src/parts/ViewletEditorCompletion/ViewletEditorCompletion.ipc.js

@@ -4,12 +4,12 @@ import * as ViewletEditorCompletion from './ViewletEditorCompletion.js'
 // prettier-ignore
 export const Commands = {
   'EditorCompletion.dispose': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.dispose),
-  'EditorCompletion.selectIndex': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.selectIndex),
   'EditorCompletion.focusFirst': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.focusFirst),
   'EditorCompletion.focusLast': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.focusLast),
   'EditorCompletion.focusNext': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.focusNext),
   'EditorCompletion.focusPrevious': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.focusPrevious),
   'EditorCompletion.selectCurrent': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.selectCurrent),
+  'EditorCompletion.selectIndex': Viewlet.wrapViewletCommand('EditorCompletion', ViewletEditorCompletion.selectIndex),
 }
 
 export * from './ViewletEditorCompletion.js'

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.ipc.js

@@ -0,0 +1,178 @@
+import * as LazyCommand from '../LazyCommand/LazyCommand.js'
+
+// prettier-ignore
+const Imports = {
+  ApplyEdit: () => import('../EditorCommand/EditorCommandApplyEdit.js'),
+  Blur: () => import('../EditorCommand/EditorCommandBlur.js'),
+  BraceCompletion: () => import('../EditorCommand/EditorCommandBraceCompletion.js'),
+  CancelSelection: () => import('../EditorCommand/EditorCommandCancelSelection.js'),
+  ContextMenu: () => import('../EditorCommand/EditorCommandHandleContextMenu.js'),
+  CopyLineDown: () => import('../EditorCommand/EditorCommandCopyLineDown.js'),
+  CopyLineUp: () => import('../EditorCommand/EditorCommandCopyLineUp.js'),
+  CursorCharacterLeft: () => import('../EditorCommand/EditorCommandCursorCharacterLeft.js'),
+  CursorCharacterRight: () => import('../EditorCommand/EditorCommandCursorCharacterRight.js'),
+  CursorDown: () => import('../EditorCommand/EditorCommandCursorDown.js'),
+  CursorEnd: () => import('../EditorCommand/EditorCommandCursorEnd.js'),
+  CursorHome: () => import('../EditorCommand/EditorCommandCursorHome.js'),
+  CursorSet: () => import('../EditorCommand/EditorCommandCursorSet.js'),
+  CursorUp: () => import('../EditorCommand/EditorCommandCursorUp.js'),
+  CursorWordLeft: () => import('../EditorCommand/EditorCommandCursorWordLeft.js'),
+  CursorWordPartLeft: () => import('../EditorCommand/EditorCommandCursorWordPartLeft.js'),
+  CursorWordPartRight: () => import('../EditorCommand/EditorCommandCursorWordPartRight.js'),
+  CursorWordRight: () => import('../EditorCommand/EditorCommandCursorWordRight.js'),
+  Cut: () => import('../EditorCommand/EditorCommandCut.js'),
+  DeleteAllLeft: () => import('../EditorCommand/EditorCommandDeleteAllLeft.js'),
+  DeleteAllRight: () => import('../EditorCommand/EditorCommandDeleteAllRight.js'),
+  DeleteLeft: () => import('../EditorCommand/EditorCommandDeleteCharacterLeft.js'),
+  DeleteRight: () => import('../EditorCommand/EditorCommandDeleteCharacterRight.js'),
+  DeleteWordLeft: () => import('../EditorCommand/EditorCommandDeleteWordLeft.js'),
+  DeleteWordPartLeft: () => import('../EditorCommand/EditorCommandDeleteWordPartLeft.js'),
+  DeleteWordPartRight: () => import('../EditorCommand/EditorCommandDeleteWordPartRight.js'),
+  DeleteWordRight: () => import('../EditorCommand/EditorCommandDeleteWordRight.js'),
+  EditorCompletion: () => import('../EditorCommand/EditorCommandCompletion.js'),
+  EditorComposition: () => import('../EditorCommand/EditorCommandComposition.js'),
+  EditorCopy: () => import('../EditorCommand/EditorCommandCopy.js'),
+  Format: () => import('../EditorCommand/EditorCommandFormat.js'),
+  GoToDefinition: () => import('../EditorCommand/EditorCommandGoToDefinition.js'),
+  GoToTypeDefinition: () => import('../EditorCommand/EditorCommandGoToTypeDefinition.js'),
+  HandleBeforeInputFromContentEditable: () => import('../EditorCommand/EditorCommandHandleNativeBeforeInputFromContentEditable.js'),
+  HandleDoubleClick: () => import('../EditorCommand/EditorCommandHandleDoubleClick.js'),
+  HandleMouseMove: () => import('../EditorCommand/EditorCommandHandleMouseMove.js'),
+  HandleMouseMoveWithAltKey: () => import('../EditorCommand/EditorCommandHandleMouseMoveWithAltKey.js'),
+  HandleNativeSelectionChange: () => import('../EditorCommand/EditorCommandHandleNativeSelectionChange.js'),
+  HandleScrollBarClick: () => import('../EditorCommand/EditorCommandHandleScrollBarClick.js'),
+  HandleScrollBarMove: () => import('../EditorCommand/EditorCommandHandleScrollBarMove.js'),
+  HandleSingleClick: () => import('../EditorCommand/EditorCommandHandleSingleClick.js'),
+  HandleTab: () => import('../EditorCommand/EditorCommandHandleTab.js'),
+  HandleTouchEnd: () => import('../EditorCommand/EditorCommandHandleTouchEnd.js'),
+  HandleTouchMove: () => import('../EditorCommand/EditorCommandHandleTouchMove.js'),
+  HandleTouchStart: () => import('../EditorCommand/EditorCommandHandleTouchStart.js'),
+  HandleTripleClick: () => import('../EditorCommand/EditorCommandHandleTripleClick.js'),
+  IndentLess: () => import('../EditorCommand/EditorCommandIndentLess.js'),
+  IndentMore: () => import('../EditorCommand/EditorCommandIndentMore.js'),
+  InsertLineBreak: () => import('../EditorCommand/EditorCommandInsertLineBreak.js'),
+  MoveLineDown: () => import('../EditorCommand/EditorCommandMoveLineDown.js'),
+  MoveLineUp: () => import('../EditorCommand/EditorCommandMoveLineUp.js'),
+  MoveRectangleSelection: () => import('../EditorCommand/EditorCommandMoveRectangleSelection.js'),
+  MoveRectangleSelectionPx: () => import('../EditorCommand/EditorCommandMoveRectangleSelectionPx.js'),
+  MoveSelection: () => import('../EditorCommand/EditorCommandMoveSelection.js'),
+  MoveSelectionPx: () => import('../EditorCommand/EditorCommandMoveSelectionPx.js'),
+  Paste: () => import('../EditorCommand/EditorCommandPaste.js'),
+  PasteText: () => import('../EditorCommand/EditorCommandPasteText.js'),
+  Save: () => import('../EditorCommand/EditorCommandSave.js'),
+  SelectAll: () => import('../EditorCommand/EditorCommandSelectAll.js'),
+  SelectAllOccurrences: () => import('../EditorCommand/EditorCommandSelectAllOccurrences.js'),
+  SelectCharacterLeft: () => import('../EditorCommand/EditorCommandSelectCharacterLeft.js'),
+  SelectCharacterRight: () => import('../EditorCommand/EditorCommandSelectCharacterRight.js'),
+  SelectDown: () => import('../EditorCommand/EditorCommandSelectDown.js'),
+  SelectInsideString: () => import('../EditorCommand/EditorCommandSelectInsideString.js'),
+  SelectLine: () => import('../EditorCommand/EditorCommandSelectLine.js'),
+  SelectNextOccurrence: () => import('../EditorCommand/EditorCommandSelectNextOccurrence.js'),
+  SelectUp: () => import('../EditorCommand/EditorCommandSelectUp.js'),
+  SelectWord: () => import('../EditorCommand/EditorCommandSelectWord.js'),
+  SelectWordLeft: () => import('../EditorCommand/EditorCommandSelectWordLeft.js'),
+  SelectWordRight: () => import('../EditorCommand/EditorCommandSelectWordRight.js'),
+  SetDecorations: () => import('../EditorCommand/EditorCommandSetDecorations.js'),
+  SetDeltaY: () => import('../EditorCommand/EditorCommandSetDeltaY.js'),
+  SetLanguageId: () => import('../EditorCommand/EditorCommandSetLanguageId.js'),
+  SortLinesAscending: () => import('../EditorCommand/EditorCommandSortLinesAscending.js'),
+  TabCompletion: () => import('../EditorCommand/EditorCommandTabCompletion.js'),
+  ToggleBlockComment: () => import('../EditorCommand/EditorCommandToggleBlockComment.js'),
+  ToggleComment: () => import('../EditorCommand/EditorCommandToggleComment.js'),
+  Type: () => import('../EditorCommand/EditorCommandType.js'),
+  Undo: () => import('../EditorCommand/EditorCommandUndo.js'),
+  UnIndent: () => import('../EditorCommand/EditorCommandUnindent.js'),
+}
+
+// prettier-ignore
+export const Commands = {
+    // TODO command to set cursor position
+  'Editor.applyEdit': LazyCommand.create('EditorText', Imports.ApplyEdit, 'editorApplyEdit'),
+  'Editor.blur': LazyCommand.create('EditorText', Imports.Blur, 'editorBlur'), // TODO needed?
+  'Editor.braceCompletion': LazyCommand.create('EditorText', Imports.BraceCompletion, 'editorBraceCompletion'),
+  'Editor.cancelSelection': LazyCommand.create('EditorText', Imports.CancelSelection, 'editorCancelSelection'),
+  'Editor.close': LazyCommand.create('EditorText', Imports.EditorCompletion, 'close'),
+  'Editor.compositionEnd': LazyCommand.create('EditorText', Imports.EditorComposition,'editorCompositionEnd'),
+  'Editor.compositionStart': LazyCommand.create('EditorText', Imports.EditorComposition,'editorCompositionStart'),
+  'Editor.compositionUpdate': LazyCommand.create('EditorText', Imports.EditorComposition,'editorCompositionUpdate'),
+  'Editor.copy': LazyCommand.create('EditorText', Imports.EditorCopy, 'editorCopy'),
+  'Editor.copyLineDown': LazyCommand.create('EditorText', Imports.CopyLineDown, 'editorCopyLineDown'),
+  'Editor.copyLineUp': LazyCommand.create('EditorText', Imports.CopyLineUp, 'editorCopyLineUp'),
+  'Editor.cursorCharacterLeft': LazyCommand.create('EditorText', Imports.CursorCharacterLeft, 'editorCursorCharacterLeft'),
+  'Editor.cursorCharacterRight': LazyCommand.create('EditorText', Imports.CursorCharacterRight, 'editorCursorCharacterRight'),
+  'Editor.cursorDown': LazyCommand.create('EditorText', Imports.CursorDown, 'editorCursorDown'),
+  'Editor.cursorEnd': LazyCommand.create('EditorText', Imports.CursorEnd, 'editorCursorEnd'),
+  'Editor.cursorHome': LazyCommand.create('EditorText', Imports.CursorHome, 'editorCursorsHome'),
+  'Editor.cursorLeft': LazyCommand.create('EditorText', Imports.CursorCharacterLeft, 'editorCursorCharacterLeft'),
+  'Editor.cursorRight': LazyCommand.create('EditorText', Imports.CursorCharacterRight, 'editorCursorCharacterRight'),
+  'Editor.cursorSet': LazyCommand.create('EditorText', Imports.CursorSet, 'editorCursorSet') ,
+  'Editor.cursorUp': LazyCommand.create('EditorText', Imports.CursorUp, 'editorCursorsUp'),
+  'Editor.cursorWordLeft': LazyCommand.create('EditorText', Imports.CursorWordLeft, 'editorCursorWordLeft'),
+  'Editor.cursorWordPartLeft': LazyCommand.create('EditorText', Imports.CursorWordPartLeft,'editorCursorWordPartLeft'),
+  'Editor.cursorWordPartRight': LazyCommand.create('EditorText', Imports.CursorWordPartRight, 'editorCursorWordPartRight'),
+  'Editor.cursorWordRight': LazyCommand.create('EditorText', Imports.CursorWordRight, 'editorCursorWordRight'),
+  'Editor.cut': LazyCommand.create('EditorText', Imports.Cut, 'editorCut'),
+  'Editor.deleteAllLeft': LazyCommand.create('EditorText', Imports.DeleteAllLeft, 'editorDeleteAllLeft'),
+  'Editor.deleteAllRight': LazyCommand.create('EditorText', Imports.DeleteAllRight, 'editorDeleteAllRight'),
+  'Editor.deleteLeft': LazyCommand.create('EditorText', Imports.DeleteLeft, 'editorDeleteCharacterLeft'),
+  'Editor.deleteRight': LazyCommand.create('EditorText', Imports.DeleteRight, 'editorDeleteCharacterRight'),
+  'Editor.deleteWordLeft': LazyCommand.create('EditorText', Imports.DeleteWordLeft, 'editorDeleteWordLeft'),
+  'Editor.deleteWordPartLeft': LazyCommand.create('EditorText', Imports.DeleteWordPartLeft, 'editorDeleteWordPartLeft'),
+  'Editor.deleteWordPartRight': LazyCommand.create('EditorText', Imports.DeleteWordPartRight, 'editorDeleteWordPartRight'),
+  'Editor.deleteWordRight': LazyCommand.create('EditorText', Imports.DeleteWordRight, 'editorDeleteWordRight'),
+  'Editor.format': LazyCommand.create('EditorText', Imports.Format, 'editorFormat'),
+  'Editor.goToDefinition': LazyCommand.create('EditorText', Imports.GoToDefinition, 'editorGoToDefinition'),
+  'Editor.goToTypeDefinition': LazyCommand.create('EditorText', Imports.GoToTypeDefinition, 'editorGoToTypeDefinition'),
+  'Editor.handleBeforeInputFromContentEditable': LazyCommand.create('EditorText', Imports.HandleBeforeInputFromContentEditable, 'handleBeforeInputFromContentEditable'),
+  'Editor.handleContextMenu': LazyCommand.create('EditorText', Imports.ContextMenu, 'editorHandleContextMenu'),
+  'Editor.handleDoubleClick': LazyCommand.create('EditorText', Imports.HandleDoubleClick, 'editorHandleDoubleClick'),
+  'Editor.handleMouseMove': LazyCommand.create('EditorText', Imports.HandleMouseMove, 'editorHandleMouseMove'),
+  'Editor.handleMouseMoveWithAltKey': LazyCommand.create('EditorText', Imports.HandleMouseMoveWithAltKey, 'editorHandleMouseMoveWithAltKey'),
+  'Editor.handleNativeSelectionChange': LazyCommand.create('EditorText', Imports.HandleNativeSelectionChange, 'editorHandleNativeSelectionChange'),
+  'Editor.handleScrollBarClick': LazyCommand.create('EditorText', Imports.HandleScrollBarClick, 'editorHandleScrollBarClick'),
+  'Editor.handleScrollBarMove': LazyCommand.create('EditorText', Imports.HandleScrollBarMove, 'editorHandleScrollBarMove'),
+  'Editor.handleSingleClick': LazyCommand.create('EditorText', Imports.HandleSingleClick, 'editorHandleSingleClick'),
+  'Editor.handleTab': LazyCommand.create('EditorText', Imports.HandleTab, 'editorHandleTab'),
+  'Editor.handleTouchEnd': LazyCommand.create('EditorText', Imports.HandleTouchEnd, 'editorHandleTouchEnd'),
+  'Editor.handleTouchMove': LazyCommand.create('EditorText', Imports.HandleTouchMove, 'editorHandleTouchMove'),
+  'Editor.handleTouchStart': LazyCommand.create('EditorText', Imports.HandleTouchStart, 'editorHandleTouchstart'),
+  'Editor.handleTripleClick': LazyCommand.create('EditorText', Imports.HandleTripleClick, 'editorHandleTripleClick'),
+  'Editor.indentLess': LazyCommand.create('EditorText', Imports.IndentLess, 'editorIndentLess'),
+  'Editor.indentMore': LazyCommand.create('EditorText', Imports.IndentMore, 'editorIndentMore'),
+  'Editor.insertLineBreak': LazyCommand.create('EditorText', Imports.InsertLineBreak, 'editorInsertLineBreak'),
+  'Editor.moveLineDown': LazyCommand.create('EditorText', Imports.MoveLineDown, 'editorMoveLineDown'),
+  'Editor.moveLineUp': LazyCommand.create('EditorText', Imports.MoveLineUp, 'editorMoveLineUp'),
+  'Editor.moveRectangleSelection': LazyCommand.create('EditorText', Imports.MoveRectangleSelection, 'editorMoveRectangleSelection'),
+  'Editor.moveRectangleSelectionPx': LazyCommand.create('EditorText', Imports.MoveRectangleSelectionPx, 'editorMoveRectangleSelectionPx'),
+  'Editor.moveSelection': LazyCommand.create('EditorText', Imports.MoveSelection, 'editorMoveSelection'),
+  'Editor.moveSelectionPx': LazyCommand.create('EditorText', Imports.MoveSelectionPx, 'editorMoveSelectionPx'),
+  'Editor.openCompletion': LazyCommand.create('EditorText', Imports.EditorCompletion, 'open'),
+  'Editor.openCompletionFromType': LazyCommand.create('EditorText', Imports.EditorCompletion, 'openFromType'),
+  'Editor.paste': LazyCommand.create('EditorText', Imports.Paste, 'editorPaste'),
+  'Editor.pasteText': LazyCommand.create('EditorText', Imports.PasteText, 'editorPasteText'),
+  'Editor.save': LazyCommand.create('EditorText', Imports.Save, 'editorSave'),
+  'Editor.selectAll': LazyCommand.create('EditorText', Imports.SelectAll, 'editorSelectAll'),
+  'Editor.selectAllOccurrences': LazyCommand.create('EditorText', Imports.SelectAllOccurrences, 'editorSelectAllOccurrences'),
+  'Editor.selectCharacterLeft': LazyCommand.create('EditorText', Imports.SelectCharacterLeft, 'editorSelectCharacterLeft'),
+  'Editor.selectCharacterRight': LazyCommand.create('EditorText', Imports.SelectCharacterRight, 'editorSelectCharacterRight'),
+  'Editor.selectDown': LazyCommand.create('EditorText', Imports.SelectDown, 'selectDown'),
+  'Editor.selectInsideString': LazyCommand.create('EditorText', Imports.SelectInsideString, 'editorSelectInsideString'),
+  'Editor.selectLine': LazyCommand.create('EditorText', Imports.SelectLine, 'editorSelectLine'),
+  'Editor.selectNextOccurrence': LazyCommand.create('EditorText', Imports.SelectNextOccurrence, 'editorSelectNextOccurrence'),
+  'Editor.selectUp': LazyCommand.create('EditorText', Imports.SelectUp, 'selectUp'),
+  'Editor.selectWord': LazyCommand.create('EditorText', Imports.SelectWord, 'editorSelectWord'),
+  'Editor.selectWordLeft': LazyCommand.create('EditorText', Imports.SelectWordLeft, 'editorSelectWordLeft'),
+  'Editor.selectWordRight': LazyCommand.create('EditorText', Imports.SelectWordRight, 'editorSelectWordRight'),
+  'Editor.setDecorations': LazyCommand.create('EditorText', Imports.SetDecorations, 'setDecorations'),
+  'Editor.setDeltaY': LazyCommand.create('EditorText', Imports.SetDeltaY, 'editorSetDeltaY'),
+  'Editor.setLanguageId': LazyCommand.create('EditorText', Imports.SetLanguageId, 'setLanguageId'),
+  'Editor.sortLinesAscending': LazyCommand.create('EditorText', Imports.SortLinesAscending, 'sortLinesAscending'),
+  'Editor.tabCompletion': LazyCommand.create('EditorText', Imports.TabCompletion, 'editorTabCompletion'),
+  'Editor.toggleBlockComment': LazyCommand.create('EditorText', Imports.ToggleBlockComment, 'editorToggleBlockComment'),
+  'Editor.toggleComment': LazyCommand.create('EditorText', Imports.ToggleComment, 'editorToggleComment'),
+  'Editor.type': LazyCommand.create('EditorText', Imports.Type, 'editorType'),
+  'Editor.undo': LazyCommand.create('EditorText', Imports.Undo, 'editorUndo'),
+  'Editor.unindent': LazyCommand.create('EditorText', Imports.UnIndent, 'selectUp'),
+}
+
+export * from './ViewletEditorText.js'

package/static/{e2dcaea → b10f46d}/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.js

@@ -39,7 +39,6 @@ export const name = 'EditorText'
 
 // TODO uri?
 export const create = (id, uri, left, top, width, height) => {
-  console.log({ id })
   const instanceId = Id.create()
   const state = Editor.create(instanceId, uri, 'unknown', '')
   const newState = Editor.setBounds(state, top, left, height, COLUMN_WIDTH)
@@ -143,7 +142,6 @@ const handleLanguagesChanged = async () => {
   )
 
   const newEditor = instances.EditorText.state
-  console.log({ newEditor })
 
   GlobalEventBus.emitEvent('editor.languageChange', newEditor, newLanguageId)
   // console.log({ state })

package/static/{e2dcaea → b10f46d}/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.ipc.js

@@ -1,5 +1,23 @@
 import * as Viewlet from '../Viewlet/Viewlet.js'
 import * as ViewletExplorer from './ViewletExplorer.js'
+import * as LazyCommand from '../LazyCommand/LazyCommand.js'
+
+// prettier-ignore
+const Imports = {
+  ExpandRecursively: () => import('./ViewletExplorerExpandRecursively.js'),
+  Focus: () => import('./ViewletExplorerFocus.js'),
+  FocusFirst: () => import('./ViewletExplorerFocusFirst.js'),
+  FocusIndex: () => import('./ViewletExplorerFocusIndex.js'),
+  FocusLast: () => import('./ViewletExplorerFocusLast.js'),
+  FocusNext: () => import('./ViewletExplorerFocusNext.js'),
+  FocusNone: () => import('./ViewletExplorerFocusNone.js'),
+  FocusPrevious: () => import('./ViewletExplorerFocusPrevious.js'),
+  HandleContextMenuKeyboard: () => import('./ViewletExplorerHandleContextMenuKeyboard.js'),
+  HandleContextMenuMouseAt: ()=>import('./ViewletExplorerHandleContextMenuMouseAt.js'),
+  HandleDragOver: () => import('./ViewletExplorerHandleDragOver.js'),
+  HandleDrop: () => import('./ViewletExplorerHandleDrop.js'),
+
+}
 
 // prettier-ignore
 export const Commands = {
@@ -11,23 +29,26 @@ export const Commands = {
   'Explorer.copyPath':                  Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyPath),
   'Explorer.copyRelativePath':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyRelativePath),
   'Explorer.expandAll':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.expandAll),
-  'Explorer.expandRecursively':         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.expandRecursively),
-  'Explorer.focus':                     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focus),
-  'Explorer.focusFirst':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusFirst),
-  'Explorer.focusIndex':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusIndex),
-  'Explorer.focusLast':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusLast),
-  'Explorer.focusNext':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNext),
-  'Explorer.focusNone':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNone),
-  'Explorer.focusPrevious':             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusPrevious),
+  'Explorer.expandRecursively':         LazyCommand.create('Explorer', Imports.ExpandRecursively, 'expandRecursively'),
+  'Explorer.focus':                     LazyCommand.create('Explorer', Imports.Focus, 'focus'),
+  'Explorer.focusFirst':                LazyCommand.create('Explorer', Imports.FocusFirst, 'focusFirst'),
+  'Explorer.focusIndex':                LazyCommand.create('Explorer', Imports.FocusIndex, 'focusIndex'),
+  'Explorer.focusLast':                 LazyCommand.create('Explorer', Imports.FocusLast, 'focusLast'),
+  'Explorer.focusNext':                 LazyCommand.create('Explorer', Imports.FocusNext, 'focusNext'),
+  'Explorer.focusNone':                 LazyCommand.create('Explorer', Imports.FocusNone, 'focusNone'),
+  'Explorer.focusPrevious':             LazyCommand.create('Explorer', Imports.FocusPrevious, 'focusPrevious'),
   'Explorer.getFocusedDirent':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.getFocusedDirent),
   'Explorer.handleArrowLeft':           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowLeft),
   'Explorer.handleArrowRight':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowRight),
   'Explorer.handleBlur':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleBlur),
   'Explorer.handleClick':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClick),
+  'Explorer.handleClickAt':             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClickAt),
   'Explorer.handleClickCurrent':        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClickCurrent),
-  'Explorer.handleContextMenuKeyboard': Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleContextMenuKeyboard),
-  'Explorer.handleContextMenuMouse':    Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleContextMenuMouse),
+  'Explorer.handleContextMenuKeyboard': LazyCommand.create('Explorer', Imports.HandleContextMenuKeyboard, 'handleContextMenuKeyboard'),
+  'Explorer.handleContextMenuMouseAt':  LazyCommand.create('Explorer', Imports.HandleContextMenuMouseAt, 'handleContextMenuMouseAt'),
   'Explorer.handleCopy':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleCopy),
+  'Explorer.handleDragOver':            LazyCommand.create('Explorer', Imports.HandleDragOver, 'handleDragOver'),
+  'Explorer.handleDrop':                LazyCommand.create('Explorer', Imports.HandleDrop, 'handleDrop'),
   'Explorer.handleMouseEnter':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseEnter),
   'Explorer.handleMouseLeave':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseLeave),
   'Explorer.handlePaste':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handlePaste),