@lvce-editor/server 0.2.2 → 0.4.1

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerHandleDropIndex.js

@@ -0,0 +1,60 @@
+import {
+  getChildDirents,
+  getParentStartIndex,
+} from './ViewletExplorerShared.js'
+import * as DirentType from '../DirentType/DirentType.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import { handleDropRoot } from './ViewletExplorerHandleDropRoot.js'
+
+const handleDropIntoFolder = async (state, dirent, index, files) => {
+  console.log({ dirent, files })
+  const { pathSeparator, root, dirents } = state
+  for (const file of files) {
+    const from = file.path
+    const to = dirent.path + pathSeparator + file.name
+    await FileSystem.copy(from, to)
+  }
+  const childDirents = await getChildDirents(root, pathSeparator, dirent)
+  // TODO merge with child dirents
+  const middleDirents = []
+  const startIndex = index + 1
+  const endIndex = index + 2
+  const mergedDirents = [
+    ...dirents.slice(0, startIndex),
+    ...childDirents,
+    ...dirents.slice(endIndex),
+  ]
+
+  // const mergedDirents = mergeDirents(dirents, childDirents)
+  console.log({ childDirents })
+  return {
+    ...state,
+    dirents: mergedDirents,
+    dropTargets: [],
+  }
+}
+
+const handleDropIntoFile = (state, dirent, index, files) => {
+  const { dirents } = state
+  const parentIndex = getParentStartIndex(dirents, index)
+  if (parentIndex === -1) {
+    return handleDropRoot(state, files)
+  }
+  return handleDropIndex(parentIndex)
+}
+
+export const handleDropIndex = (state, index, files) => {
+  const { dirents } = state
+  const dirent = dirents[index]
+  // TODO if it is a file, drop into the folder of the file
+  // TODO if it is a folder, drop into the folder
+  // TODO if it is a symlink, read symlink and determine if file can be dropped
+  switch (dirent.type) {
+    case DirentType.Directory:
+      return handleDropIntoFolder(state, dirent, index, files)
+    case DirentType.File:
+      return handleDropIntoFile(state, dirent, index, files)
+    default:
+      return state
+  }
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorerHandleDropRoot.js

@@ -0,0 +1,30 @@
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import { getChildDirents } from './ViewletExplorerShared.js'
+
+const mergeDirents = (oldDirents, newDirents) => {
+  return newDirents
+}
+
+// TODO copy files in parallel
+const copyFiles = async (root, pathSeparator, files) => {
+  for (const file of files) {
+    const from = file.path
+    const to = root + pathSeparator + file.name
+    await FileSystem.copy(from, to)
+  }
+}
+
+export const handleDropRoot = async (state, files) => {
+  const { root, pathSeparator, dirents } = state
+  await copyFiles(root, pathSeparator, files)
+  const childDirents = await getChildDirents(root, pathSeparator, {
+    path: root,
+    depth: 0,
+  })
+  const mergedDirents = mergeDirents(dirents, childDirents)
+  return {
+    ...state,
+    dirents: mergedDirents,
+    dropTargets: [],
+  }
+}

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

@@ -0,0 +1,116 @@
+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
+}
+
+export const mergeDirents = (oldDirents, newDirents) => {
+  const merged = []
+  let oldIndex = 0
+  for (const newDirent of newDirents) {
+    merged.push(newDirent)
+    for (let i = oldIndex; i < oldDirents.length; i++) {
+      if (oldDirents[i].path === newDirent.path) {
+        // TOOD copy children of old dirent
+        oldIndex = i
+        break
+      }
+    }
+  }
+  return merged
+}

package/static/b10f46d/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'

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

@@ -5,12 +5,12 @@ import * as ExtensionsMarketplace from '../ExtensionMarketplace/ExtensionMarketp
 import * as Platform from '../Platform/Platform.js'
 import * as Assert from '../Assert/Assert.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const ITEM_HEIGHT = 62
-
-const MINIMUM_SLIDER_SIZE = 20
-
-export const HEADER_HEIGHT = 35.94 // TODO improve this
+import {
+  getListHeight,
+  HEADER_HEIGHT,
+  ITEM_HEIGHT,
+  MINIMUM_SLIDER_SIZE,
+} from './ViewletExtensionsShared.js'
 
 const SUGGESTIONS = [
   '@builtin',
@@ -58,10 +58,6 @@ const getVisible = (state) => {
   return state.filteredExtensions.slice(state.minLineY, state.maxLineY)
 }
 
-const getListHeight = (state) => {
-  return state.height - HEADER_HEIGHT
-}
-
 export const loadContent = async (state) => {
   // TODO just get local extensions on demand (not when query string is already different)
 
@@ -346,102 +342,7 @@ export const handleInput = async (state, value) => {
   }
 }
 
-export const focusIndex = (state, index) => {
-  if (index === -1) {
-    return {
-      ...state,
-      focusedIndex: -1,
-    }
-  }
-  const listHeight = getListHeight(state)
-  if (index < state.minLineY + 1) {
-    // scroll up
-    const minLineY = index
-    const maxLineY = minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
-    const negativeMargin = -minLineY * ITEM_HEIGHT
-    return {
-      ...state,
-      focusedIndex: index,
-      minLineY,
-      maxLineY,
-      negativeMargin,
-    }
-  }
-  if (index >= state.maxLineY - 1) {
-    //  scroll down
-    const maxLineY = index + 1
-    const minLineY = maxLineY - Math.ceil(listHeight / ITEM_HEIGHT)
-    const negativeMargin =
-      -minLineY * ITEM_HEIGHT + (listHeight % ITEM_HEIGHT) - ITEM_HEIGHT
-    return {
-      ...state,
-      focusedIndex: index,
-      minLineY,
-      maxLineY,
-      negativeMargin,
-    }
-  }
-  return {
-    ...state,
-    focusedIndex: index,
-  }
-}
-
 // TODO lazyload this
-export const handleClick = (state, index) => {
-  return focusIndex(state, index)
-}
-
-export const focusNext = (state) => {
-  if (state.focusedIndex === state.filteredExtensions.length - 1) {
-    return state
-  }
-  return focusIndex(state, state.focusedIndex + 1)
-}
-
-export const focusNextPage = (state) => {
-  if (state.focusedIndex === state.filteredExtensions.length - 1) {
-    return state
-  }
-  const indexNextPage = Math.min(
-    state.maxLineY + (state.maxLineY - state.minLineY) - 2,
-    state.filteredExtensions.length - 1
-  )
-  return focusIndex(state, indexNextPage)
-}
-
-export const focusPrevious = (state) => {
-  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
-    return state
-  }
-  return focusIndex(state, state.focusedIndex - 1)
-}
-
-export const focusPreviousPage = (state) => {
-  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
-    return state
-  }
-
-  const indexPreviousPage = Math.max(
-    state.minLineY - (state.maxLineY - state.minLineY) + 1,
-    0
-  )
-  return focusIndex(state, indexPreviousPage)
-}
-
-export const focusFirst = (state) => {
-  if (state.filteredExtensions.length === 0) {
-    return state
-  }
-  return focusIndex(state, 0)
-}
-
-export const focusLast = (state) => {
-  if (state.filteredExtensions.length === 0) {
-    return state
-  }
-  return focusIndex(state, state.filteredExtensions.length - 1)
-}
 
 // TODO show error / warning  when installment fails / times out
 export const handleInstall = async (state, id) => {

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusFirst.js

@@ -0,0 +1,8 @@
+import { focusIndex } from './ViewletExtensionsFocusIndex.js'
+
+export const focusFirst = (state) => {
+  if (state.filteredExtensions.length === 0) {
+    return state
+  }
+  return focusIndex(state, 0)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusIndex.js

@@ -0,0 +1,42 @@
+import { getListHeight, ITEM_HEIGHT } from './ViewletExtensionsShared.js'
+
+export const focusIndex = (state, index) => {
+  if (index === -1) {
+    return {
+      ...state,
+      focusedIndex: -1,
+    }
+  }
+  const listHeight = getListHeight(state)
+  if (index < state.minLineY + 1) {
+    // scroll up
+    const minLineY = index
+    const maxLineY = minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
+    const negativeMargin = -minLineY * ITEM_HEIGHT
+    return {
+      ...state,
+      focusedIndex: index,
+      minLineY,
+      maxLineY,
+      negativeMargin,
+    }
+  }
+  if (index >= state.maxLineY - 1) {
+    //  scroll down
+    const maxLineY = index + 1
+    const minLineY = maxLineY - Math.ceil(listHeight / ITEM_HEIGHT)
+    const negativeMargin =
+      -minLineY * ITEM_HEIGHT + (listHeight % ITEM_HEIGHT) - ITEM_HEIGHT
+    return {
+      ...state,
+      focusedIndex: index,
+      minLineY,
+      maxLineY,
+      negativeMargin,
+    }
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusLast.js

@@ -0,0 +1,8 @@
+import { focusIndex } from './ViewletExtensionsFocusIndex.js'
+
+export const focusLast = (state) => {
+  if (state.filteredExtensions.length === 0) {
+    return state
+  }
+  return focusIndex(state, state.filteredExtensions.length - 1)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusNext.js

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

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusNextPage.js

@@ -0,0 +1,12 @@
+import { focusIndex } from './ViewletExtensionsFocusIndex.js'
+
+export const focusNextPage = (state) => {
+  if (state.focusedIndex === state.filteredExtensions.length - 1) {
+    return state
+  }
+  const indexNextPage = Math.min(
+    state.maxLineY + (state.maxLineY - state.minLineY) - 2,
+    state.filteredExtensions.length - 1
+  )
+  return focusIndex(state, indexNextPage)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusPrevious.js

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

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsFocusPreviousPage.js

@@ -0,0 +1,13 @@
+import { focusIndex } from './ViewletExtensionsFocusIndex.js'
+
+export const focusPreviousPage = (state) => {
+  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
+    return state
+  }
+
+  const indexPreviousPage = Math.max(
+    state.minLineY - (state.maxLineY - state.minLineY) + 1,
+    0
+  )
+  return focusIndex(state, indexPreviousPage)
+}

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsHandleClick.js

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

package/static/b10f46d/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensionsShared.js

@@ -0,0 +1,9 @@
+export const ITEM_HEIGHT = 62
+
+export const MINIMUM_SLIDER_SIZE = 20
+
+export const HEADER_HEIGHT = 35.94 // TODO improve this
+
+export const getListHeight = (state) => {
+  return state.height - HEADER_HEIGHT
+}

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

@@ -0,0 +1 @@
+export const Commands = {}

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

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

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

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

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

@@ -8,7 +8,7 @@ import * as Viewlet from '../Viewlet/Viewlet.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 import * as ViewletManager from '../ViewletManager/ViewletManager.js'
 import * as Workspace from '../Workspace/Workspace.js'
-
+import * as ViewletModule from '../ViewletModule/ViewletModule.js'
 const COLUMN_WIDTH = 9 // TODO compute this automatically once
 
 // interface Editor {
@@ -193,7 +193,7 @@ export const contentLoaded = async (state) => {
   const width = state.width
   const height = state.height - TAB_HEIGHT
   const instance = ViewletManager.create(
-    ViewletManager.getModule,
+    ViewletModule.load,
     id,
     'Main',
     editor.uri,
@@ -229,7 +229,7 @@ export const openUri = async (state, uri) => {
   for (const editor of state.editors) {
     if (editor.uri === uri) {
       const instance = ViewletManager.create(
-        ViewletManager.getModule,
+        ViewletModule.load,
         id,
         'Main',
         uri,
@@ -245,7 +245,7 @@ export const openUri = async (state, uri) => {
     }
   }
   const instance = ViewletManager.create(
-    ViewletManager.getModule,
+    ViewletModule.load,
     id,
     'Main',
     uri,
@@ -410,7 +410,7 @@ export const focusIndex = (state, index) => {
   const height = state.height - TAB_HEIGHT
 
   const viewlet = ViewletManager.create(
-    ViewletManager.getModule,
+    ViewletModule.load,
     id,
     'Main',
     editor.uri,