@lvce-editor/server 0.5.0 → 0.6.0

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/Viewlet/Viewlet.ipc.js

@@ -1,4 +1,3 @@
-import * as Command from '../Command/Command.js'
 import * as Viewlet from './Viewlet.js'
 
 export const Commands = {

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/Viewlet/Viewlet.js

@@ -224,6 +224,9 @@ export const openWidget = async (id, ...args) => {
     show: false,
     focus: true,
   })
+  if (!commands) {
+    throw new Error('expected commands to be of type array')
+  }
 
   if (hasInstance) {
     commands.unshift(['Viewlet.dispose', id])

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/Viewlet/ViewletExtensionsList.js

@@ -5,7 +5,7 @@ import * as ExtensionsMarketplace from '../ExtensionMarketplace/ExtensionMarketp
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Assert from '../Assert/Assert.js'
-
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
 export const ITEM_HEIGHT = 62
 
 const MINIMUM_SLIDER_SIZE = 20
@@ -378,7 +378,7 @@ export const handleContextMenu = async (state, x, y, extensionId) => {
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
-    /* id */ 'manageExtension'
+    /* id */ MenuEntryId.ManageExtension
   )
 }
 

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBar.js

@@ -4,6 +4,7 @@ import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
 import * as I18nString from '../I18NString/I18NString.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
 
 /**
  * @enum {string}
@@ -263,7 +264,7 @@ export const handleContextMenu = async (state, x, y) => {
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
-    /* id */ 'activityBar'
+    /* id */ MenuEntryId.ActivityBar
   )
   return state
 }

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarHandleClick.js

@@ -1,12 +1,13 @@
 import * as Command from '../Command/Command.js'
 import * as Layout from '../Layout/Layout.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
 
 const handleClickSettings = async (state, x, y, viewletId) => {
   await Command.execute(
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
-    /* id */ 'settings'
+    /* id */ MenuEntryId.Settings
   )
   return state
 }
@@ -16,7 +17,7 @@ const handleClickAdditionalViews = async (state, x, y, viewletId) => {
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
-    /* id */ 'activity-bar-additional-views'
+    /* id */ MenuEntryId.ActivityBarAdditionalViews
   )
   return state
 }

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorFindWidget/ViewletEditorFindWidget.ipc.js

@@ -0,0 +1,11 @@
+import * as ViewletEditorFindWidget from './ViewletEditorFindWidget.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'EditorFindWidget.handleInput': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.handleInput),
+  'EditorFindWidget.focusNext': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.focusNext),
+  'EditorFindWidget.focusPrevious': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.focusPrevious),
+}
+
+export * from './ViewletEditorFindWidget.js'

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorFindWidget/ViewletEditorFindWidget.js

@@ -0,0 +1,200 @@
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as TextDocumentSearch from '../TextDocumentSearch/TextDocumentSearch.js'
+import * as Command from '../Command/Command.js'
+
+export const name = 'EditorFindWidget'
+
+export const create = () => {
+  return {
+    value: '',
+    matchIndex: 0,
+    totalMatches: 0,
+    ariaAnnouncement: '',
+  }
+}
+
+export const getPosition = () => {
+  const editor = ViewletStates.getState('EditorText')
+  if (!editor) {
+    return {
+      top: 0,
+      left: 0,
+      width: 0,
+      height: 0,
+    }
+  }
+  const width = 200
+  const height = 30
+  const paddingTop = 10
+  const paddingRight = 20
+  const left = editor.left + editor.width - width - paddingRight
+  const top = editor.top + paddingTop
+  return {
+    top,
+    left,
+    width,
+    height,
+  }
+}
+
+const getMatchCount = (matches) => {
+  return matches.length / 2
+}
+
+export const loadContent = (state) => {
+  const editor = ViewletStates.getState('EditorText')
+  if (!editor) {
+    return state
+  }
+  const { selections, lines } = editor
+  const startRowIndex = selections[0]
+  const startColumnIndex = selections[1]
+  const endRowIndex = selections[2]
+  const endColumnIndex = selections[3]
+  const line = lines[startRowIndex]
+  const value = line.slice(startColumnIndex, endColumnIndex)
+  const matches = TextDocumentSearch.findMatches(lines, value)
+  const totalMatches = getMatchCount(matches)
+
+  return {
+    ...state,
+    value,
+    matchIndex: 1,
+    totalMatches,
+  }
+}
+
+export const handleInput = (state, value) => {
+  // TODO get focused editor
+  // highlight locations that match value
+  const editor = ViewletStates.getState('EditorText')
+  const { lines, selections } = editor
+  const startRowIndex = selections[0]
+  const startColumnIndex = selections[1]
+  const endRowIndex = selections[2]
+  const endColumnIndex = selections[3]
+  const matches = TextDocumentSearch.findMatches(lines, value)
+  const totalMatches = getMatchCount(matches)
+  return {
+    ...state,
+    value,
+    totalMatches,
+  }
+}
+
+// TODO this function should be synchronous
+export const focusNext = async (state) => {
+  const { value, matchIndex } = state
+  const editor = ViewletStates.getState('EditorText')
+  const { lines, selections } = editor
+  const startRowIndex = selections[0]
+  const startColumnIndex = selections[1]
+  const endRowIndex = selections[2]
+  const endColumnIndex = selections[3]
+  // TODO find next match and highlight it
+  const nextMatch = TextDocumentSearch.findNextMatch(
+    lines,
+    value,
+    startRowIndex + 1
+  )
+  const newSelections = new Uint32Array([
+    nextMatch.rowIndex,
+    nextMatch.columnIndex,
+    nextMatch.rowIndex,
+    nextMatch.columnIndex + value.length,
+  ])
+  // TODO set selections synchronously and render input match index,
+  // input value and new selections at the same time
+  await Command.execute('Editor.setSelections', newSelections)
+  // TODO reveal new position in editor
+  return {
+    ...state,
+    matchIndex: matchIndex + 1,
+  }
+}
+
+// TODO should be synchronous
+export const focusPrevious = async (state) => {
+  const { value, matchIndex } = state
+  const editor = ViewletStates.getState('EditorText')
+  const { lines, selections } = editor
+  const startRowIndex = selections[0]
+  const startColumnIndex = selections[1]
+  const endRowIndex = selections[2]
+  const endColumnIndex = selections[3]
+  // TODO find next match and highlight it
+  const nextMatch = TextDocumentSearch.findPreviousMatch(
+    lines,
+    value,
+    startRowIndex - 1
+  )
+  const newSelections = new Uint32Array([
+    nextMatch.rowIndex,
+    nextMatch.columnIndex,
+    nextMatch.rowIndex,
+    nextMatch.columnIndex + value.length,
+  ])
+  // TODO set selections synchronously and render input match index,
+  // input value and new selections at the same time
+  await Command.execute('Editor.setSelections', newSelections)
+  // TODO reveal new position in editor
+  return {
+    ...state,
+    matchIndex: matchIndex - 1,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderValue = {
+  isEqual(oldState, newState) {
+    return oldState.value === newState.value
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorFindWidget',
+      /* method */ 'setValue',
+      /* value */ newState.value,
+    ]
+  },
+}
+
+const renderMatchCount = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.matchIndex === newState.matchIndex &&
+      oldState.totalMatches === newState.totalMatches
+    )
+  },
+  apply(oldState, newState) {
+    const matchCountText = `${newState.matchIndex} of ${newState.totalMatches}`
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorFindWidget',
+      /* method */ 'setMatchCountText',
+      /* value */ matchCountText,
+    ]
+  },
+}
+
+const getAriaLabel = (state) => {
+  return `${state.matchIndex} of ${state.totalMatches} found for ${state.value}`
+}
+
+const renderAriaAnnouncement = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.ariaAnnouncement === newState.ariaAnnouncement &&
+      oldState.matchIndex === newState.matchIndex &&
+      oldState.totalMatches === newState.totalMatches &&
+      oldState.value === newState.value
+    )
+  },
+  apply(oldState, newState) {
+    const ariaLabel = getAriaLabel(newState)
+    return [/* Viewlet.invoke */ 'Viewlet.ariaAnnounce', /* text */ ariaLabel]
+  },
+}
+
+export const render = [renderValue, renderMatchCount, renderAriaAnnouncement]

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.ipc.js

@@ -1,12 +1,23 @@
-import * as ViewletEditorImage from './ViewletEditorImage.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletEditorImage from './ViewletEditorImage.js'
+import * as LazyCommand from '../LazyCommand/LazyCommand.js'
+
+// prettier-ignore
+const Imports = {
+  CopyImage: () => import('./ViewletEditorImageCopyImage.js'),
+  CopyPath: ()=>import('./ViewletEditorImageCopyPath.js'),
+  HandleContextMenu:()=>import('./ViewletEditorImageHandleContextMenu.js')
+}
 
 // prettier-ignore
 export const Commands = {
+  'EditorImage.copyImage': LazyCommand.create('EditorImage', Imports.CopyImage, 'copyImage'),
+  'EditorImage.handleContextMenu': LazyCommand.create('EditorImage', Imports.HandleContextMenu, 'handleContextMenu'),
   'EditorImage.handlePointerDown': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerDown),
   'EditorImage.handlePointerMove': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerMove),
   'EditorImage.handlePointerUp': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerUp),
   'EditorImage.handleWheel': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handleWheel),
+  'EditorImage.copyPath': LazyCommand.create('EditorImage', Imports.CopyPath, 'copyPath'),
 }
 
 export * from './ViewletEditorImage.js'

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.js

@@ -2,6 +2,7 @@ import * as Assert from '../Assert/Assert.js'
 import * as Clamp from '../Clamp/Clamp.js'
 import * as Command from '../Command/Command.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
 
 export const name = 'EditorImage'
 
@@ -178,6 +179,9 @@ export const handlePointerMove = (state, pointerId, x, y) => {
 
 export const handlePointerUp = (state, pointerId, x, y) => {
   const { eventCache, pointerDownCount } = state
+  if (pointerDownCount === 0) {
+    return state
+  }
   const index = eventCache.findIndex((event) => event.pointerId === pointerId)
   const newEventCache = [
     ...eventCache.slice(0, index),

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImageCopyImage.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+
+export const copyImage = async (state) => {
+  const blob = await Command.execute('Ajax.getBlob', state.src)
+  await Command.execute('ClipBoard.writeImage', blob)
+  return state
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImageCopyPath.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+
+export const copyPath = async (state) => {
+  await Command.execute('ClipBoard.writeText', state.uri)
+  return state
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImageHandleContextMenu.js

@@ -0,0 +1,12 @@
+import * as Command from '../Command/Command.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
+
+export const handleContextMenu = async (state, x, y) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ MenuEntryId.EditorImage
+  )
+  return state
+}

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.ipc.js

@@ -32,6 +32,8 @@ const Imports = {
   EditorCompletion: () => import('../EditorCommand/EditorCommandCompletion.js'),
   EditorComposition: () => import('../EditorCommand/EditorCommandComposition.js'),
   EditorCopy: () => import('../EditorCommand/EditorCommandCopy.js'),
+  EditorFind: () => import('../EditorCommand/EditorCommandOpenFind.js'),
+  EditorSetSelections: () => import('../EditorCommand/EditorCommandSetSelections.js'),
   Format: () => import('../EditorCommand/EditorCommandFormat.js'),
   GoToDefinition: () => import('../EditorCommand/EditorCommandGoToDefinition.js'),
   GoToTypeDefinition: () => import('../EditorCommand/EditorCommandGoToTypeDefinition.js'),
@@ -148,6 +150,7 @@ export const Commands = {
   '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.openFind': LazyCommand.create('EditorText', Imports.EditorFind, 'openFind'),
   'Editor.paste': LazyCommand.create('EditorText', Imports.Paste, 'editorPaste'),
   'Editor.pasteText': LazyCommand.create('EditorText', Imports.PasteText, 'editorPasteText'),
   'Editor.save': LazyCommand.create('EditorText', Imports.Save, 'editorSave'),
@@ -166,6 +169,7 @@ export const Commands = {
   '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.setSelections': LazyCommand.create('EditorText', Imports.EditorSetSelections, 'setSelections'),
   'Editor.sortLinesAscending': LazyCommand.create('EditorText', Imports.SortLinesAscending, 'sortLinesAscending'),
   'Editor.tabCompletion': LazyCommand.create('EditorText', Imports.TabCompletion, 'editorTabCompletion'),
   'Editor.toggleBlockComment': LazyCommand.create('EditorText', Imports.ToggleBlockComment, 'editorToggleBlockComment'),

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.js

@@ -4,12 +4,13 @@ import * as ExtensionHostSemanticTokens from '../ExtensionHost/ExtensionHostSema
 // import * as ExtensionHostTextDocument from '../ExtensionHost/ExtensionHostTextDocument.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as Id from '../Id/Id.js'
 import * as Languages from '../Languages/Languages.js'
 import * as Preferences from '../Preferences/Preferences.js'
 import * as Tokenizer from '../Tokenizer/Tokenizer.js'
-import * as Id from '../Id/Id.js'
-import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as Workspace from '../Workspace/Workspace.js'
 
 const COLUMN_WIDTH = 9 // TODO compute this automatically once
 
@@ -42,12 +43,14 @@ export const create = (id, uri, left, top, width, height) => {
   const instanceId = Id.create()
   const state = Editor.create(instanceId, uri, 'unknown', '')
   const newState = Editor.setBounds(state, top, left, height, COLUMN_WIDTH)
-  const languageId = Languages.getLanguageId(uri)
+  const fileName = Workspace.pathBaseName(state.uri)
+  const languageId = Languages.getLanguageId(fileName)
   return {
     ...newState,
     uri,
     rowHeight: 20,
     languageId,
+    width,
   }
 }
 
@@ -55,7 +58,8 @@ export const loadContent = async (state) => {
   const rowHeight = Preferences.get('editor.lineHeight') || 20
   const fontSize = Preferences.get('editor.fontSize') || 15 // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
   const letterSpacing = Preferences.get('editor.letterSpacing') || 0.5
-  const languageId = Languages.getLanguageId(state.uri)
+  const fileName = Workspace.pathBaseName(state.uri)
+  const languageId = Languages.getLanguageId(fileName)
   const tokenizer = Tokenizer.getTokenizer(languageId)
   const content = await getContent(state.uri)
   const newState = Editor.setText(state, content)
@@ -108,7 +112,8 @@ export const contentLoadedEffects = async (state) => {
   GlobalEventBus.addListener('languages.changed', handleLanguagesChanged)
   GlobalEventBus.addListener('tokenizer.changed', handleTokenizeChange)
   GlobalEventBus.addListener('editor.change', handleEditorChange)
-  const newLanguageId = Languages.getLanguageId(state.uri)
+  const fileName = Workspace.pathBaseName(state.uri)
+  const newLanguageId = Languages.getLanguageId(fileName)
   await Command.execute(
     /* Editor.setLanguageId */ 'Editor.setLanguageId',
     /* languageId */ newLanguageId
@@ -127,7 +132,8 @@ const handleLanguagesChanged = async () => {
     return
   }
   const state = instance.state
-  const newLanguageId = Languages.getLanguageId(state.uri)
+  const fileName = Workspace.pathBaseName(state.uri)
+  const newLanguageId = Languages.getLanguageId(fileName)
   state.languageId = newLanguageId
   // await ExtensionHostTextDocument.handleEditorLanguageChange(state)
   // if (state.languageId === newLanguageId) {

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.ipc.js

@@ -16,6 +16,7 @@ const Imports = {
   HandleContextMenuMouseAt: ()=>import('./ViewletExplorerHandleContextMenuMouseAt.js'),
   HandleDragOver: () => import('./ViewletExplorerHandleDragOver.js'),
   HandleDrop: () => import('./ViewletExplorerHandleDrop.js'),
+  HandlePaste: () => import('./ViewletExplorerHandlePaste.js'),
 
 }
 
@@ -52,7 +53,7 @@ export const Commands = {
   '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),
+  'Explorer.handlePaste':                    LazyCommand.create('Explorer', Imports.HandlePaste, 'handlePaste'),
   'Explorer.handleWheel':                    Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleWheel),
   'Explorer.newFile':                        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFile),
   'Explorer.newFolder':                      Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFolder),

package/static/{4d80653 → fbac85f}/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.js

@@ -14,6 +14,7 @@ import {
   getIndexFromPosition,
   getParentEndIndex,
   getParentStartIndex,
+  getTopLevelDirents,
   mergeDirents,
 } from './ViewletExplorerShared.js'
 import * as PathSeparatorType from '../PathSeparatorType/PathSeparatorType.js'
@@ -85,17 +86,6 @@ export const contentLoaded = async (state) => {
   // TODO this should a promise and be awaited
 }
 
-const getTopLevelDirents = (root, pathSeparator) => {
-  if (!root) {
-    return []
-  }
-  return getChildDirents(root, pathSeparator, {
-    depth: 0,
-    path: root,
-    type: DirentType.Directory,
-  })
-}
-
 // export const contentLoadedEffects = (state) => {
 //   // TODO why is this event emitted?
 //   GlobalEventBus.emitEvent('dirents.update', state.dirents)
@@ -888,98 +878,6 @@ export const handleCopy = async (state) => {
   )
 }
 
-const handlePasteNone = (state, nativeFiles) => {
-  console.info('[ViewletExplorer/handlePaste] no paths detected')
-  return state
-}
-
-// TODO add lots of tests for this
-export const updateRoot = async () => {
-  const state1 = Viewlet.getState('Explorer')
-  if (state1.disposed) {
-    return state1
-  }
-  // const file = nativeFiles.files[0]
-  const topLevelDirents = await getTopLevelDirents(
-    state1.root,
-    state1.pathSeparator
-  )
-  const state2 = Viewlet.getState('Explorer')
-  // TODO what if root changes while reading directories?
-  if (state2.disposed || state2.root !== state1.root) {
-    return state2
-  }
-  const newDirents = mergeDirents(state2.dirents, topLevelDirents)
-  const state3 = {
-    ...state2,
-    dirents: newDirents,
-  }
-  return state3
-}
-
-const handlePasteCopy = async (state, nativeFiles) => {
-  // TODO handle pasting files into nested folder
-  // TODO handle pasting files into symlink
-  // TODO handle pasting files into broken symlink
-  // TODO handle pasting files into hardlink
-  // TODO what if folder is big and it takes a long time
-  for (const source of nativeFiles.files) {
-    const target = `${state.root}${state.pathSeparator}${getBaseName(
-      source,
-      state.pathSeparator
-    )}`
-    await FileSystem.copy(source, target)
-  }
-  const stateNow = Viewlet.getState('Explorer')
-  if (stateNow.disposed) {
-    return
-  }
-  // TODO only update folder at which level it changed
-  return updateRoot()
-}
-
-const handlePasteCut = async (state, nativeFiles) => {
-  for (const source of nativeFiles.files) {
-    const target = `${state.root}${state.pathSeparator}${getBaseName(source)}`
-    await FileSystem.rename(source, target)
-  }
-  return state
-}
-
-const NativeFileTypes = {
-  None: 'none',
-  Copy: 'copy',
-  Cut: 'cut',
-}
-
-export const handlePaste = async (state) => {
-  const nativeFiles = await Command.execute(
-    /* ClipBoard.readNativeFiles */ 'ClipBoard.readNativeFiles'
-  )
-  // TODO detect cut/paste event, not sure if that is possible
-  // TODO check that pasted folder is not a parent folder of opened folder
-  // TODO support pasting multiple paths
-  // TODO what happens when pasting multiple paths, but some of them error?
-  // how many error messages should be shown? Should the operation be undone?
-  // TODO what if it is a large folder and takes a long time to copy? Should show progress
-  // TODO what if there is a permission error? Probably should show a modal to ask for permission
-  // TODO if error is EEXISTS, just rename the copy (e.g. file-copy-1.txt, file-copy-2.txt)
-  // TODO actual target should be selected folder
-  // TODO but what if a file is currently selected? Then maybe the parent folder
-  // TODO but will it work if the folder is a symlink?
-  // TODO handle error gracefully when copy fails
-  switch (nativeFiles.type) {
-    case NativeFileTypes.None:
-      return handlePasteNone(state, nativeFiles)
-    case NativeFileTypes.Copy:
-      return handlePasteCopy(state, nativeFiles)
-    case NativeFileTypes.Cut:
-      return handlePasteCut(state, nativeFiles)
-    default:
-      throw new Error(`unexpected native paste type: ${nativeFiles.type}`)
-  }
-}
-
 export const hasFunctionalResize = true
 
 export const resize = (state, dimensions) => {