@lvce-editor/server 0.2.2 → 0.3.0

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

@@ -1,6 +1,5 @@
 import * as Assert from '../Assert/Assert.js'
 import * as Command from '../Command/Command.js'
-import * as Compare from '../Compare/Compare.js'
 import * as DirentType from '../DirentType/DirentType.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
@@ -8,6 +7,14 @@ import * as IconTheme from '../IconTheme/IconTheme.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Viewlet from '../Viewlet/Viewlet.js' // TODO should not import viewlet manager -> avoid cyclic dependency
 import * as Workspace from '../Workspace/Workspace.js'
+import { focusIndex } from './ViewletExplorerFocusIndex.js'
+import {
+  compareDirent,
+  getChildDirents,
+  getIndexFromPosition,
+  getParentEndIndex,
+  getParentStartIndex,
+} from './ViewletExplorerShared.js'
 // TODO viewlet should only have create and refresh functions
 // every thing else can be in a separate module <viewlet>.lazy.js
 // and  <viewlet>.ipc.js
@@ -17,90 +24,6 @@ import * as Workspace from '../Workspace/Workspace.js'
 
 export const name = 'Explorer'
 
-const getParentStartIndex = (dirents, index) => {
-  const dirent = dirents[index]
-  let startIndex = index - 1
-  while (startIndex >= 0 && dirents[startIndex].depth >= dirent.depth) {
-    startIndex--
-  }
-  return startIndex
-}
-
-const getParentEndIndex = (dirents, index) => {
-  const dirent = dirents[index]
-  let endIndex = index + 1
-  while (endIndex < dirents.length && dirents[endIndex].depth > dirent.depth) {
-    endIndex++
-  }
-  return endIndex
-}
-
-const priorityMapFoldersFirst = {
-  folder: 1,
-  directory: 1,
-  file: 0,
-  unknown: 0,
-  socket: 0,
-}
-
-const compareDirentType = (direntA, direntB) => {
-  return (
-    priorityMapFoldersFirst[direntB.type] -
-    priorityMapFoldersFirst[direntA.type]
-  )
-}
-
-const compareDirentName = (direntA, direntB) => {
-  return Compare.compareString(direntA.name, direntB.name)
-}
-
-const compareDirent = (direntA, direntB) => {
-  return (
-    compareDirentType(direntA, direntB) || compareDirentName(direntA, direntB)
-  )
-}
-
-const toDisplayDirents = (root, pathSeparator, rawDirents, parentDirent) => {
-  rawDirents.sort(compareDirent) // TODO maybe shouldn't mutate input argument, maybe sort after mapping
-  // TODO figure out whether this uses too much memory (name,path -> redundant, depth could be computed on demand)
-  const toDisplayDirent = (rawDirent, index) => {
-    const path = parentDirent.path
-      ? [parentDirent.path, rawDirent.name].join(pathSeparator)
-      : [root, rawDirent.name].join(pathSeparator)
-    return {
-      name: rawDirent.name,
-      posInSet: index + 1,
-      setSize: rawDirents.length,
-      depth: parentDirent.depth + 1,
-      type: rawDirent.type,
-      path, // TODO storing absolute path might be too costly, could also store relative path here
-      icon: IconTheme.getIcon(rawDirent),
-    }
-  }
-  return rawDirents.map(toDisplayDirent)
-}
-
-const getChildDirents = async (root, pathSeparator, parentDirent) => {
-  Assert.string(root)
-  Assert.string(pathSeparator)
-  Assert.object(parentDirent)
-  // TODO use event/actor based code instead, this is impossible to cancel right now
-  // also cancel updating when opening new folder
-  // const dispose = state => state.pendingRequests.forEach(cancelRequest)
-  // TODO should use FileSystem directly in this case because it is globally available anyway
-  // and more typesafe than Command.execute
-  // and more performant
-  const uri = parentDirent.path
-  const rawDirents = await FileSystem.readDirWithFileTypes(uri)
-  const displayDirents = toDisplayDirents(
-    root,
-    pathSeparator,
-    rawDirents,
-    parentDirent
-  )
-  return displayDirents
-}
-
 // TODO instead of root string, there should be a root dirent
 
 export const create = (id, uri, left, top, width, height) => {
@@ -166,7 +89,7 @@ const getTopLevelDirents = (root, pathSeparator) => {
   return getChildDirents(root, pathSeparator, {
     depth: 0,
     path: root,
-    type: 'directory',
+    type: DirentType.Directory,
   })
 }
 
@@ -242,34 +165,6 @@ export const handleWheel = (state, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY)
 }
 
-export const handleContextMenuKeyboard = async (state, index) => {
-  const x = state.left
-  const y = state.top + (index - state.minLineY + 1) * state.itemHeight
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ 'explorer'
-  )
-  return {
-    ...state,
-    focusedIndex: index,
-  }
-}
-
-export const handleContextMenuMouse = async (state, x, y, index) => {
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ 'explorer'
-  )
-  return {
-    ...state,
-    focusedIndex: index,
-  }
-}
-
 export const getFocusedDirent = (state) => {
   const dirent = state.dirents[state.focusedIndex]
   return dirent
@@ -792,93 +687,15 @@ export const handleClick = async (state, index) => {
   }
 }
 
-export const focusNone = (state) => {
-  return focusIndex(state, -1)
+export const handleClickAt = (state, x, y) => {
+  const index = getIndexFromPosition(state, x, y)
+  return handleClick(state, index)
 }
 
 export const handleClickCurrent = (state) => {
   return handleClick(state, state.focusedIndex - state.minLineY)
 }
 
-export const focusIndex = (state, index) => {
-  if (index < state.minLineY) {
-    if (index < 0) {
-      return {
-        ...state,
-        focusedIndex: index,
-        focused: true,
-      }
-    }
-    const diff = state.maxLineY - state.minLineY
-    return {
-      ...state,
-      focusedIndex: index,
-      focused: true,
-      minLineY: index,
-      maxLineY: index + diff,
-    }
-  } else if (index >= state.maxLineY) {
-    const diff = state.maxLineY - state.minLineY
-    return {
-      ...state,
-      focusedIndex: index,
-      focused: true,
-      minLineY: index + 1 - diff,
-      maxLineY: index + 1,
-    }
-  }
-  return {
-    ...state,
-    focusedIndex: index,
-    focused: true,
-  }
-}
-
-export const focus = (state) => {
-  return {
-    ...state,
-    focused: true,
-  }
-}
-
-export const focusNext = (state) => {
-  if (state.focusedIndex === state.dirents.length - 1) {
-    return state
-  }
-  return focusIndex(state, state.focusedIndex + 1)
-}
-
-export const focusPrevious = (state) => {
-  switch (state.focusedIndex) {
-    case -1:
-      if (state.dirents.length === 0) {
-        return state
-      }
-      return focusIndex(state, state.dirents.length - 1)
-    case 0:
-      return state
-    default:
-      return focusIndex(state, state.focusedIndex - 1)
-  }
-}
-
-export const focusFirst = (state) => {
-  if (state.dirents.length === 0 || state.focusedIndex === 0) {
-    return state
-  }
-  return focusIndex(state, 0)
-}
-
-export const focusLast = (state) => {
-  if (
-    state.dirents.length === 0 ||
-    state.focusedIndex === state.dirents.length - 1
-  ) {
-    return state
-  }
-  return focusIndex(state, state.dirents.length - 1)
-}
-
 export const scrollUp = () => {}
 
 export const scrollDown = () => {}
@@ -1431,46 +1248,6 @@ export const revealItem = async (state, uri) => {
   return revealItemVisible(state, index)
 }
 
-export const expandRecursively = async (state) => {
-  const { dirents, focusedIndex, pathSeparator, root } = state
-  const dirent = dirents[focusedIndex]
-  if (
-    dirent.type !== DirentType.Directory &&
-    dirent.type !== DirentType.DirectoryExpanding
-  ) {
-    return state
-  }
-  // TODO this is very inefficient
-  const getChildDirentsRecursively = async (dirent) => {
-    switch (dirent.type) {
-      case DirentType.File:
-        return [dirent]
-      case DirentType.Directory:
-        const childDirents = await getChildDirents(root, pathSeparator, dirent)
-        const all = [dirent]
-        for (const childDirent of childDirents) {
-          const childAll = await getChildDirentsRecursively(childDirent)
-          all.push(...childAll)
-        }
-        return all
-      default:
-        return []
-    }
-  }
-  // TODO race condition: what if folder is being collapse while it is recursively expanding?
-  // TODO race condition: what if folder is being deleted while it is recursively expanding?
-  // TODO race condition: what if a new file/folder is created while the folder is recursively expanding?
-  const childDirents = await getChildDirentsRecursively(dirent)
-  const startIndex = focusedIndex
-  const endIndex = getParentEndIndex(dirents, focusedIndex)
-  const newDirents = [
-    ...dirents.slice(0, startIndex),
-    ...childDirents,
-    ...dirents.slice(endIndex),
-  ]
-  return { ...state, dirents: newDirents }
-}
-
 export const shouldApplyNewState = (newState, fn) => {
   if (newState.root !== Workspace.state.workspacePath) {
     console.log(

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerExpandRecursively.js

@@ -0,0 +1,55 @@
+import * as DirentType from '../DirentType/DirentType.js'
+import { getChildDirents, getParentEndIndex } from './ViewletExplorerShared.js'
+
+export const expandRecursively = async (state) => {
+  const { dirents, focusedIndex, pathSeparator, root } = state
+  const dirent =
+    focusedIndex < 0
+      ? {
+          type: DirentType.Directory,
+          path: root,
+          depth: 0,
+        }
+      : dirents[focusedIndex]
+  if (
+    dirent.type !== DirentType.Directory &&
+    dirent.type !== DirentType.DirectoryExpanding
+  ) {
+    return state
+  }
+  // TODO this is very inefficient
+  const getChildDirentsRecursively = async (dirent) => {
+    switch (dirent.type) {
+      case DirentType.File:
+        return [dirent]
+      case DirentType.Directory:
+        const childDirents = await getChildDirents(root, pathSeparator, dirent)
+        const all = [dirent]
+        for (const childDirent of childDirents) {
+          const childAll = await getChildDirentsRecursively(childDirent)
+          all.push(...childAll)
+        }
+        return all
+      default:
+        return []
+    }
+  }
+  // TODO race condition: what if folder is being collapse while it is recursively expanding?
+  // TODO race condition: what if folder is being deleted while it is recursively expanding?
+  // TODO race condition: what if a new file/folder is created while the folder is recursively expanding?
+  const childDirents = await getChildDirentsRecursively(dirent)
+  const startIndex = focusedIndex
+  if (focusedIndex >= 0) {
+    const endIndex = getParentEndIndex(dirents, focusedIndex)
+    const newDirents = [
+      ...dirents.slice(0, startIndex),
+      ...childDirents,
+      ...dirents.slice(endIndex),
+    ]
+    return { ...state, dirents: newDirents }
+  }
+  return {
+    ...state,
+    dirents: childDirents.slice(1),
+  }
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocus.js

@@ -0,0 +1,9 @@
+export const focus = (state) => {
+  if (state.focused) {
+    return state
+  }
+  return {
+    ...state,
+    focused: true,
+  }
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusFirst.js

@@ -0,0 +1,9 @@
+import { focusIndex } from './ViewletExplorerFocusIndex.js'
+
+export const focusFirst = (state) => {
+  const { focusedIndex, dirents } = state
+  if (dirents.length === 0 || focusedIndex === 0) {
+    return state
+  }
+  return focusIndex(state, 0)
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusIndex.js

@@ -0,0 +1,33 @@
+export const focusIndex = (state, index) => {
+  if (index < state.minLineY) {
+    if (index < 0) {
+      return {
+        ...state,
+        focusedIndex: index,
+        focused: true,
+      }
+    }
+    const diff = state.maxLineY - state.minLineY
+    return {
+      ...state,
+      focusedIndex: index,
+      focused: true,
+      minLineY: index,
+      maxLineY: index + diff,
+    }
+  } else if (index >= state.maxLineY) {
+    const diff = state.maxLineY - state.minLineY
+    return {
+      ...state,
+      focusedIndex: index,
+      focused: true,
+      minLineY: index + 1 - diff,
+      maxLineY: index + 1,
+    }
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+    focused: true,
+  }
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusLast.js

@@ -0,0 +1,9 @@
+import { focusIndex } from './ViewletExplorerFocusIndex.js'
+
+export const focusLast = (state) => {
+  const { focusedIndex, dirents } = state
+  if (dirents.length === 0 || focusedIndex === dirents.length - 1) {
+    return state
+  }
+  return focusIndex(state, dirents.length - 1)
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusNext.js

@@ -0,0 +1,9 @@
+import { focusIndex } from './ViewletExplorerFocusIndex.js'
+
+export const focusNext = (state) => {
+  const { focusedIndex, dirents } = state
+  if (focusedIndex === dirents.length - 1) {
+    return state
+  }
+  return focusIndex(state, focusedIndex + 1)
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusNone.js

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

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerFocusPrevious.js

@@ -0,0 +1,16 @@
+import { focusIndex } from './ViewletExplorerFocusIndex.js'
+
+export const focusPrevious = (state) => {
+  const { focusedIndex, dirents } = state
+  switch (focusedIndex) {
+    case -1:
+      if (dirents.length === 0) {
+        return state
+      }
+      return focusIndex(state, dirents.length - 1)
+    case 0:
+      return state
+    default:
+      return focusIndex(state, focusedIndex - 1)
+  }
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerHandleContextMenuKeyboard.js

@@ -0,0 +1,14 @@
+import * as Command from '../Command/Command.js'
+
+export const handleContextMenuKeyboard = async (state) => {
+  const { focusedIndex, left, top, minLineY, itemHeight } = state
+  const x = left
+  const y = top + (focusedIndex - minLineY + 1) * itemHeight
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'explorer'
+  )
+  return state
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerHandleContextMenuMouseAt.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Command from '../Command/Command.js'
+import { getIndexFromPosition } from './ViewletExplorerShared.js'
+
+export const handleContextMenuMouseAt = async (state, x, y) => {
+  Assert.number(x)
+  Assert.number(y)
+  const focusedIndex = getIndexFromPosition(state, x, y)
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'explorer'
+  )
+  return {
+    ...state,
+    focusedIndex,
+    focused: false,
+  }
+}

package/static/37517d2/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerShared.js

@@ -0,0 +1,100 @@
+import * as Compare from '../Compare/Compare.js'
+import * as Assert from '../Assert/Assert.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as DirentType from '../DirentType/DirentType.js'
+import * as IconTheme from '../IconTheme/IconTheme.js'
+
+export const getIndexFromPosition = (state, x, y) => {
+  const { top, itemHeight, dirents } = state
+  const index = Math.floor((y - top) / itemHeight)
+  if (index < 0) {
+    return 0
+  }
+  if (index > dirents.length) {
+    return -1
+  }
+  return index
+}
+
+const priorityMapFoldersFirst = {
+  [DirentType.Directory]: 1,
+  [DirentType.File]: 0,
+  [DirentType.Unknown]: 0,
+  [DirentType.Socket]: 0,
+}
+
+const compareDirentType = (direntA, direntB) => {
+  return (
+    priorityMapFoldersFirst[direntB.type] -
+    priorityMapFoldersFirst[direntA.type]
+  )
+}
+
+const compareDirentName = (direntA, direntB) => {
+  return Compare.compareString(direntA.name, direntB.name)
+}
+
+export const compareDirent = (direntA, direntB) => {
+  return (
+    compareDirentType(direntA, direntB) || compareDirentName(direntA, direntB)
+  )
+}
+
+const toDisplayDirents = (root, pathSeparator, rawDirents, parentDirent) => {
+  rawDirents.sort(compareDirent) // TODO maybe shouldn't mutate input argument, maybe sort after mapping
+  // TODO figure out whether this uses too much memory (name,path -> redundant, depth could be computed on demand)
+  const toDisplayDirent = (rawDirent, index) => {
+    const path = parentDirent.path
+      ? [parentDirent.path, rawDirent.name].join(pathSeparator)
+      : [root, rawDirent.name].join(pathSeparator)
+    return {
+      name: rawDirent.name,
+      posInSet: index + 1,
+      setSize: rawDirents.length,
+      depth: parentDirent.depth + 1,
+      type: rawDirent.type,
+      path, // TODO storing absolute path might be too costly, could also store relative path here
+      icon: IconTheme.getIcon(rawDirent),
+    }
+  }
+  return rawDirents.map(toDisplayDirent)
+}
+
+export const getParentStartIndex = (dirents, index) => {
+  const dirent = dirents[index]
+  let startIndex = index - 1
+  while (startIndex >= 0 && dirents[startIndex].depth >= dirent.depth) {
+    startIndex--
+  }
+  return startIndex
+}
+
+export const getParentEndIndex = (dirents, index) => {
+  const dirent = dirents[index]
+  let endIndex = index + 1
+  while (endIndex < dirents.length && dirents[endIndex].depth > dirent.depth) {
+    endIndex++
+  }
+  return endIndex
+}
+
+export const getChildDirents = async (root, pathSeparator, parentDirent) => {
+  Assert.string(root)
+  Assert.string(pathSeparator)
+  Assert.object(parentDirent)
+  // TODO use event/actor based code instead, this is impossible to cancel right now
+  // also cancel updating when opening new folder
+  // const dispose = state => state.pendingRequests.forEach(cancelRequest)
+  // TODO should use FileSystem directly in this case because it is globally available anyway
+  // and more typesafe than Command.execute
+  // and more performant
+  const uri = parentDirent.path
+  const rawDirents = await FileSystem.readDirWithFileTypes(uri)
+  const displayDirents = toDisplayDirents(
+    root,
+    pathSeparator,
+    rawDirents,
+    parentDirent
+  )
+  return displayDirents
+}

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

@@ -0,0 +1,39 @@
+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'),
+}
+
+// prettier-ignore
+export const Commands = {
+  'Extensions.closeSuggest': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.closeSuggest),
+  'Extensions.focusFirst': LazyCommand.create('Extensions', Imports.FocusFirst, 'focusFirst'),
+  'Extensions.focusIndex': LazyCommand.create('Extensions', Imports.FocusIndex, 'focusIndex'),
+  'Extensions.focusLast': LazyCommand.create('Extensions', Imports.FocusLast, 'focusLast'),
+  'Extensions.focusNext': LazyCommand.create('Extensions', Imports.FocusNext, 'focusNext'),
+  'Extensions.focusNextPage': LazyCommand.create('Extensions', Imports.FocusNextPage, 'focusNextPage'),
+  'Extensions.focusPrevious': LazyCommand.create('Extensions', Imports.FocusPrevious, 'focusPrevious'),
+  'Extensions.focusPreviousPage': LazyCommand.create(Imports.FocusPreviousPage, 'focusPreviousPage'),
+  'Extensions.handleClick': LazyCommand.create('Extensions', Imports.HandleClick, 'handleClick'),
+  'Extensions.handleContextMenu': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleContextMenu),
+  'Extensions.handleInput': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleInput),
+  'Extensions.handleInstall': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleInstall),
+  'Extensions.handleScrollBarClick': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleScrollBarClick),
+  'Extensions.handleScrollBarMove': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleScrollBarMove),
+  'Extensions.handleUninstall': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleUninstall),
+  'Extensions.handleWheel': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleWheel),
+  'Extensions.openSuggest': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.openSuggest),
+  'Extensions.setDeltaY': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.setDeltaY),
+  'Extensions.toggleSuggest': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.toggleSuggest),
+}
+
+export * from './ViewletExtensions.js'