@lvce-editor/server 0.0.28 → 0.0.31

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletEditorCompletion/ViewletEditorCompletion.js

@@ -0,0 +1,258 @@
+import * as Command from '../Command/Command.js'
+import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
+import * as ExtensionHostCompletion from '../ExtensionHost/ExtensionHostCompletion.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as IconTheme from '../IconTheme/IconTheme.js'
+import * as EditorShowMessage from '../EditorCommand/EditorCommandShowMessage.js'
+
+export const create = (id, uri, top, left, width, height) => {
+  console.log({ id, uri, top, left, width, height })
+  return {
+    completionItems: [],
+    focusedIndex: 0,
+    isOpened: false,
+    openingReason: 0,
+    editor: undefined,
+    abortController: new AbortController(),
+    rowIndex: 0,
+    columnIndex: 0,
+    leadingWord: '',
+    loadingTimeout: -1,
+    filteredCompletionItems: [],
+    visibleItems: [],
+    x: 0,
+    y: 0,
+  }
+}
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+const getCompletions = async (editor) => {
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  // Editor.sync(editor)
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  const completions = await ExtensionHostCompletion.executeCompletionProvider(
+    editor,
+    offset
+  )
+  return completions
+}
+
+const filterCompletionItems = (completionItems, word) => {
+  const includesWord = (completionItem) => {
+    return completionItem.label.includes(word)
+  }
+  const filteredCompletions = completionItems.filter(includesWord)
+  return filteredCompletions
+}
+
+const getEditor = () => {
+  return Viewlet.getState('EditorText')
+}
+
+const getLabel = (item) => {
+  return item.label
+}
+
+const getIconClassName = (item) => {
+  switch (item.kind) {
+    case /* Property */ 1:
+      return 'IconProperty'
+    case /* Value */ 2:
+      return 'IconValue'
+    case /* Function */ 3:
+      return 'IconFunction'
+    case /* Variable */ 4:
+      return 'IconVariable'
+    case /* Keyword */ 5:
+      return 'IconKeyword'
+    case /* Folder */ 6:
+      return IconTheme.getFolderIcon({ name: item.label })
+    case /* File */ 7:
+      return IconTheme.getFileIcon({ name: item.label })
+    default:
+      return 'IconDefault'
+  }
+}
+
+const getVisibleItems = (filteredItems) => {
+  const visibleItems = []
+  for (const filteredItem of filteredItems) {
+    visibleItems.push({
+      label: getLabel(filteredItem),
+      icon: getIconClassName(filteredItem),
+    })
+  }
+  return visibleItems
+  // for(const )
+}
+
+const getDisplayErrorMessage = (error) => {
+  const message = `${error}`
+  const errorPrefix = 'Error: '
+  if (message.startsWith(errorPrefix)) {
+    return message.slice(errorPrefix.length)
+  }
+  return message
+}
+
+export const loadContent = async (state) => {
+  const editor = getEditor()
+  const completionItems = await getCompletions(editor)
+  const filteredCompletionItems = filterCompletionItems(completionItems, '')
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const x = EditorPosition.x(editor, rowIndex, columnIndex)
+  const y = EditorPosition.y(editor, rowIndex, columnIndex)
+  const visibleItems = getVisibleItems(filteredCompletionItems)
+  console.log({ completionItems, filteredCompletionItems, visibleItems })
+  return {
+    ...state,
+    completionItems,
+    filteredCompletionItems,
+    visibleItems,
+    x,
+    y,
+  }
+}
+
+export const handleError = async (error) => {
+  const displayErrorMessage = getDisplayErrorMessage(error)
+  const editor = getEditor()
+  await EditorShowMessage.editorShowMessage(
+    /* editor */ editor,
+    /* rowIndex */ 0,
+    /* columnIndex */ 0,
+    /* message */ displayErrorMessage,
+    /* isError */ true
+  )
+}
+
+export const loadingContent = () => {
+  const editor = getEditor()
+  console.log('show loading')
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const x = EditorPosition.x(editor, rowIndex, columnIndex)
+  const y = EditorPosition.y(editor, rowIndex, columnIndex)
+  const changes = [
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorCompletion',
+    /* method */ 'showLoading',
+    /* x */ x,
+    /* y */ y,
+  ]
+  return changes
+}
+
+export const contentLoaded = () => {
+  // noop
+}
+
+export const handleSelectionChange = (state, selectionChanges) => {}
+
+export const advance = (state, word) => {
+  const filteredCompletionItems = filterCompletionItems(
+    state.completionItems,
+    word
+  )
+  return {
+    ...state,
+    filteredCompletionItems,
+  }
+}
+
+const getInsertSnippet = (word, leadingWord) => {
+  if (word.startsWith(leadingWord)) {
+    return word.slice(leadingWord.length)
+  }
+  return word
+}
+
+const select = async (state, completionItem) => {
+  const { leadingWord } = state
+  const word = completionItem.label
+  const snippet = getInsertSnippet(word, leadingWord)
+  // TODO type and dispose commands should be sent to renderer process at the same time
+  await Command.execute(/* Editor.type */ 'Editor.type', /* text */ snippet)
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const selectIndex = (state, index) => {
+  const completionItem = state.filteredCompletionItems[index]
+  return select(state, completionItem)
+}
+
+export const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+export const focusFirst = (state) => {
+  return focusIndex(state, 0)
+}
+
+export const focusLast = (state) => {
+  return focusIndex(state, state.completionItems.length - 1)
+}
+
+export const focusPrevious = (state) => {
+  if (state.focusedIndex === 0) {
+    return focusLast(state)
+  }
+  return focusIndex(state, state.focusedIndex - 1)
+}
+
+export const focusNext = (state) => {
+  if (state.focusedIndex === state.completionItems.length - 1) {
+    return focusFirst(state)
+  }
+  return focusIndex(state, state.focusedIndex + 1)
+}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderPosition = {
+  isEqual(oldState, newState) {
+    return oldState.x === newState.x && oldState.y === newState.y
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorCompletion',
+      /* method */ 'setPosition',
+      /* x */ newState.x,
+      /* y */ newState.y,
+    ]
+  },
+}
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.visibleItems === newState.visibleItems
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorCompletion',
+      /* method */ 'setItems',
+      /* items */ newState.visibleItems,
+      /* reason */ 1,
+    ]
+  },
+}
+
+export const render = [renderItems, renderPosition]

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.ipc.js

@@ -0,0 +1,3 @@
+export const Commands = {}
+
+export * from './ViewletEditorImage.js'

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.js

@@ -0,0 +1,42 @@
+export const name = 'EditorImage'
+
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    src: '',
+    disposed: false,
+  }
+}
+
+export const loadContent = async (state) => {
+  return {
+    ...state,
+    src: 'abc',
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderSrc = {
+  isEqual(oldState, newState) {
+    return oldState.src === newState.src
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorImage',
+      /* method */ 'setSrc',
+      /* src */ `/remote${newState.src}`,
+    ]
+  },
+}
+
+export const render = [renderSrc]

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletEditorPlainText/ViewletEditorPlainText.ipc.js

@@ -0,0 +1,3 @@
+export const Commands = {}
+
+export * from './ViewletEditorPlainText.js'

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletEditorPlainText/ViewletEditorPlainText.js

@@ -0,0 +1,46 @@
+import * as FileSystem from '../FileSystem/FileSystem.js'
+
+export const name = 'PlainText'
+
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    content: 'abc',
+    uri,
+    disposed: false,
+  }
+}
+
+export const loadContent = async (state) => {
+  const content = await FileSystem.readFile(state.uri)
+  return {
+    ...state,
+    content,
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderContent = {
+  isEqual(oldState, newState) {
+    return oldState.content === newState.content
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorPlainText',
+      /* method */ 'setContent',
+      /* content */ newState.content,
+    ]
+  },
+}
+
+export const render = [renderContent]

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

@@ -0,0 +1,189 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+
+const lazyCommand = (importFn, key) => {
+  const lazyCommand = async (editor, ...args) => {
+    const module = await importFn()
+    const fn = module[key]
+    // editor might have changed during import, need to apply function to latest editor
+    const latestEditor = ViewletStates.getState('EditorText')
+    if (typeof fn !== 'function') {
+      throw new Error(`Editor.${key} is not a function`)
+    }
+    return fn(latestEditor, ...args)
+  }
+  return Viewlet.wrapViewletCommand('EditorText', lazyCommand)
+}
+
+// prettier-ignore
+const Imports = {
+  ApplyEdit: () => import('../EditorCommand/EditorCommandApplyEdit.js'),
+  Blur: () => import('../EditorCommand/EditorCommandBlur.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'),
+  SelectInsideString:()=>import('../EditorCommand/EditorCommandSelectInsideString.js'),
+  SelectLine:()=>import('../EditorCommand/EditorCommandSelectLine.js'),
+  SelectNextOccurrence:()=>import('../EditorCommand/EditorCommandSelectNextOccurrence.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'),
+  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'),
+  BraceCompletion:()=>import('../EditorCommand/EditorCommandBraceCompletion.js'),
+}
+
+// prettier-ignore
+export const Commands = {
+  'Editor.applyEdit': lazyCommand(Imports.ApplyEdit, 'editorApplyEdit'),
+  'Editor.blur': lazyCommand(Imports.Blur, 'editorBlur'), // TODO needed?
+  'Editor.braceCompletion': lazyCommand(Imports.BraceCompletion, 'editorBraceCompletion'),
+  'Editor.cancelSelection': lazyCommand(Imports.CancelSelection, 'editorCancelSelection'),
+  'Editor.close': lazyCommand(Imports.EditorCompletion, 'close'),
+  'Editor.compositionEnd': lazyCommand(Imports.EditorComposition,'editorCompositionEnd'),
+  'Editor.compositionStart': lazyCommand(Imports.EditorComposition,'editorCompositionStart'),
+  'Editor.compositionUpdate': lazyCommand(Imports.EditorComposition,'editorCompositionUpdate'),
+  'Editor.copy': lazyCommand(Imports.EditorCopy, 'editorCopy'),
+  'Editor.copyLineDown': lazyCommand(Imports.CopyLineDown, 'editorCopyLineDown'),
+  'Editor.copyLineUp': lazyCommand(Imports.CopyLineUp, 'editorCopyLineUp'),
+  'Editor.cursorCharacterLeft': lazyCommand(Imports.CursorCharacterLeft, 'editorCursorCharacterLeft'),
+  'Editor.cursorCharacterRight': lazyCommand(Imports.CursorCharacterRight, 'editorCursorCharacterRight'),
+  'Editor.cursorDown': lazyCommand(Imports.CursorDown, 'editorCursorDown'),
+  'Editor.cursorEnd': lazyCommand(Imports.CursorEnd, 'editorCursorEnd'),
+  'Editor.cursorHome': lazyCommand(Imports.CursorHome, 'editorCursorsHome'),
+  'Editor.cursorLeft': lazyCommand(Imports.CursorCharacterLeft, 'editorCursorCharacterLeft'),
+  'Editor.cursorRight': lazyCommand(Imports.CursorCharacterRight, 'editorCursorCharacterRight'),
+  'Editor.cursorSet': lazyCommand(Imports.CursorSet, 'editorCursorSet') ,
+  'Editor.cursorUp': lazyCommand(Imports.CursorUp, 'editorCursorsUp'),
+  'Editor.cursorWordLeft': lazyCommand(Imports.CursorWordLeft, 'editorCursorWordLeft'),
+  'Editor.cursorWordPartLeft': lazyCommand(Imports.CursorWordPartLeft,'editorCursorWordPartLeft'),
+  'Editor.cursorWordPartRight': lazyCommand(Imports.CursorWordPartRight, 'editorCursorWordPartRight'),
+  'Editor.cursorWordRight': lazyCommand(Imports.CursorWordRight, 'editorCursorWordRight'),
+  'Editor.cut': lazyCommand(Imports.Cut, 'editorCut'),
+  'Editor.deleteAllLeft': lazyCommand(Imports.DeleteAllLeft, 'editorDeleteAllLeft'),
+  'Editor.deleteAllRight': lazyCommand(Imports.DeleteAllRight, 'editorDeleteAllRight'),
+  'Editor.deleteLeft': lazyCommand(Imports.DeleteLeft, 'editorDeleteCharacterLeft'),
+  'Editor.deleteRight': lazyCommand(Imports.DeleteRight, 'editorDeleteCharacterRight'),
+  'Editor.deleteWordLeft': lazyCommand(Imports.DeleteWordLeft, 'editorDeleteWordLeft'),
+  'Editor.deleteWordPartLeft': lazyCommand(Imports.DeleteWordPartLeft, 'editorDeleteWordPartLeft'),
+  'Editor.deleteWordPartRight':lazyCommand(Imports.DeleteWordPartRight, 'editorDeleteWordPartRight'),
+  'Editor.deleteWordRight': lazyCommand(Imports.DeleteWordRight, 'editorDeleteWordRight'),
+  'Editor.format': lazyCommand(Imports.Format, 'editorFormat'),
+  'Editor.goToDefinition': lazyCommand(Imports.GoToDefinition, 'editorGoToDefinition'),
+  'Editor.goToTypeDefinition': lazyCommand(Imports.GoToTypeDefinition, 'editorGoToTypeDefinition'),
+  'Editor.handleBeforeInputFromContentEditable': lazyCommand(Imports.HandleBeforeInputFromContentEditable, 'handleBeforeInputFromContentEditable'),
+  'Editor.handleContextMenu': lazyCommand(Imports.ContextMenu, 'editorHandleContextMenu'),
+  'Editor.handleDoubleClick': lazyCommand(Imports.HandleDoubleClick, 'editorHandleDoubleClick'),
+  'Editor.handleMouseMove': lazyCommand(Imports.HandleMouseMove, 'editorHandleMouseMove'),
+  'Editor.handleMouseMoveWithAltKey': lazyCommand(Imports.HandleMouseMoveWithAltKey, 'editorHandleMouseMoveWithAltKey'),
+  'Editor.handleNativeSelectionChange': lazyCommand(Imports.HandleNativeSelectionChange, 'editorHandleNativeSelectionChange'),
+  'Editor.handleScrollBarClick': lazyCommand(Imports.HandleScrollBarClick, 'editorHandleScrollBarClick'),
+  'Editor.handleScrollBarMove': lazyCommand(Imports.HandleScrollBarMove, 'editorHandleScrollBarMove'),
+  'Editor.handleSingleClick': lazyCommand(Imports.HandleSingleClick, 'editorHandleSingleClick'),
+  'Editor.handleTab': lazyCommand(Imports.HandleTab, 'editorHandleTab'),
+  'Editor.handleTouchEnd': lazyCommand(Imports.HandleTouchEnd, 'editorHandleTouchEnd'),
+  'Editor.handleTouchMove': lazyCommand(Imports.HandleTouchMove, 'editorHandleTouchMove'),
+  'Editor.handleTouchStart': lazyCommand(Imports.HandleTouchStart, 'editorHandleTouchstart'),
+  'Editor.handleTripleClick': lazyCommand(Imports.HandleTripleClick, 'editorHandleTripleClick'),
+  'Editor.indentLess': lazyCommand(Imports.IndentLess, 'editorIndentLess'),
+  'Editor.indentMore': lazyCommand(Imports.IndentMore, 'editorIndentMore'),
+  'Editor.insertLineBreak': lazyCommand(Imports.InsertLineBreak, 'editorInsertLineBreak'),
+  'Editor.moveLineDown': lazyCommand(Imports.MoveLineDown, 'editorMoveLineDown'),
+  'Editor.moveLineUp': lazyCommand(Imports.MoveLineUp, 'editorMoveLineUp'),
+  'Editor.moveRectangleSelection': lazyCommand(Imports.MoveRectangleSelection, 'editorMoveRectangleSelection'),
+  'Editor.moveRectangleSelectionPx': lazyCommand(Imports.MoveRectangleSelectionPx, 'editorMoveRectangleSelectionPx'),
+  'Editor.moveSelection': lazyCommand(Imports.MoveSelection, 'editorMoveSelection'),
+  'Editor.moveSelectionPx': lazyCommand(Imports.MoveSelectionPx, 'editorMoveSelectionPx'),
+  'Editor.openCompletion': lazyCommand(Imports.EditorCompletion, 'open'),
+  'Editor.openCompletionFromType': lazyCommand(Imports.EditorCompletion, 'openFromType'),
+  'Editor.paste': lazyCommand(Imports.Paste, 'editorPaste'),
+  'Editor.pasteText': lazyCommand(Imports.PasteText, 'editorPasteText'),
+  'Editor.save': lazyCommand(Imports.Save, 'editorSave'),
+  'Editor.selectAll': lazyCommand(Imports.SelectAll, 'editorSelectAll'),
+  'Editor.selectAllOccurrences': lazyCommand(Imports.SelectAllOccurrences, 'editorSelectAllOccurrences'),
+  'Editor.selectCharacterLeft': lazyCommand(Imports.SelectCharacterLeft, 'editorSelectCharacterLeft'),
+  'Editor.selectCharacterRight': lazyCommand(Imports.SelectCharacterRight, 'editorSelectCharacterRight'),
+  'Editor.selectInsideString': lazyCommand(Imports.SelectInsideString, 'editorSelectInsideString'),
+  'Editor.selectLine': lazyCommand(Imports.SelectLine, 'editorSelectLine'),
+  'Editor.selectNextOccurrence': lazyCommand(Imports.SelectNextOccurrence, 'editorSelectNextOccurrence'),
+  'Editor.selectWord': lazyCommand(Imports.SelectWord, 'editorSelectWord'),
+  'Editor.selectWordLeft': lazyCommand(Imports.SelectWordLeft, 'editorSelectWordLeft'),
+  'Editor.selectWordRight': lazyCommand(Imports.SelectWordRight, 'editorSelectWordRight'),
+  'Editor.setDecorations': lazyCommand(Imports.SetDecorations, 'setDecorations'),
+  'Editor.setDeltaY': lazyCommand(Imports.SetDeltaY, 'editorSetDeltaY'),
+  'Editor.setLanguageId': lazyCommand(Imports.SetLanguageId, 'setLanguageId'),
+  'Editor.tabCompletion': lazyCommand(Imports.TabCompletion, 'editorTabCompletion'),
+  'Editor.toggleBlockComment': lazyCommand(Imports.ToggleBlockComment, 'editorToggleBlockComment'),
+  'Editor.toggleComment': lazyCommand(Imports.ToggleComment, 'editorToggleComment'),
+  'Editor.type': lazyCommand(Imports.Type, 'editorType'),
+  'Editor.undo': lazyCommand(Imports.Undo, 'editorUndo'),
+  'Editor.unindent': lazyCommand(Imports.UnIndent, 'editorUnindent')
+    // TODO command to set cursor position
+  // TODO command copy line up/down
+  // TODO command move line up/down
+}
+
+export * from './ViewletEditorText.js'