@lvce-editor/server 0.7.0 → 0.7.2

package/static/{bda65b1 → 18087fa}/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.js

@@ -28,15 +28,12 @@ export const create = (id, uri, left, top, width, height) => {
   }
 }
 
-const loadContentRemote = (state, uri) => {
+const getSrcRemote = (uri) => {
   const src = `/remote${uri}`
-  return {
-    ...state,
-    src,
-  }
+  return src
 }
 
-const loadContentWithBlobUrl = async (state, uri) => {
+const getSrcWithBlobUrl = async (uri) => {
   const content = await FileSystem.readFile(uri)
   const mimeType = await Command.execute('Mime.getMediaMimeType', uri)
   const blob = await Command.execute(
@@ -45,10 +42,7 @@ const loadContentWithBlobUrl = async (state, uri) => {
     mimeType
   )
   const dataUrl = await Command.execute('Url.createObjectUrl', blob)
-  return {
-    ...state,
-    src: dataUrl,
-  }
+  return dataUrl
 }
 
 const canUseRemoteLoading = (uri) => {
@@ -56,13 +50,22 @@ const canUseRemoteLoading = (uri) => {
   return protocol === ''
 }
 
+const getSrc = (uri) => {
+  if (canUseRemoteLoading(uri)) {
+    return getSrcRemote(uri)
+  }
+  return getSrcWithBlobUrl(uri)
+}
+
 // TODO revoke object url when disposed
-export const loadContent = async (state, ...args) => {
+export const loadContent = async (state, savedState) => {
+  console.log({ savedState })
   const { uri } = state
-  if (canUseRemoteLoading(uri)) {
-    return loadContentRemote(state, uri)
+  const src = await getSrc(uri)
+  return {
+    ...state,
+    src,
   }
-  return loadContentWithBlobUrl(state, uri)
 }
 
 export const contentLoaded = async (state) => {}

package/static/{bda65b1 → 18087fa}/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.js

@@ -54,7 +54,28 @@ export const create = (id, uri, left, top, width, height) => {
   }
 }
 
-export const loadContent = async (state) => {
+export const saveState = (state) => {
+  return {
+    selections: [...Array.from(state.selections)],
+    focused: state.focused,
+  }
+}
+
+const getSavedSelections = (savedState) => {
+  if (savedState && savedState.selections) {
+    return new Uint32Array(savedState.selections)
+  }
+  return new Uint32Array([0, 0, 0, 0])
+}
+
+const getSavedFocus = (savedState) => {
+  if (savedState && savedState.focused) {
+    return true
+  }
+  return false
+}
+
+export const loadContent = async (state, savedState) => {
   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
@@ -63,12 +84,16 @@ export const loadContent = async (state) => {
   const tokenizer = Tokenizer.getTokenizer(languageId)
   const content = await getContent(state.uri)
   const newState = Editor.setText(state, content)
+  const savedSelections = getSavedSelections(savedState)
+  const savedFocus = getSavedFocus(savedState)
   return {
     ...newState,
     rowHeight,
     fontSize,
     letterSpacing,
     tokenizer,
+    selections: savedSelections,
+    focused: savedFocus,
   }
 }
 

package/static/{bda65b1 → 18087fa}/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.js

@@ -4,6 +4,7 @@ import * as DirentType from '../DirentType/DirentType.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as IconTheme from '../IconTheme/IconTheme.js'
+import * as PathSeparatorType from '../PathSeparatorType/PathSeparatorType.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'
@@ -15,9 +16,8 @@ import {
   getParentEndIndex,
   getParentStartIndex,
   getTopLevelDirents,
-  mergeDirents,
 } from './ViewletExplorerShared.js'
-import * as PathSeparatorType from '../PathSeparatorType/PathSeparatorType.js'
+import * as PromiseStatus from '../PromiseStatus/PromiseStatus.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
@@ -54,15 +54,112 @@ const getPathSeparator = (root) => {
   return FileSystem.getPathSeparator(root)
 }
 
-export const loadContent = async (state) => {
-  const root = Workspace.state.workspacePath
+const isExpandedDirectory = (dirent) => {
+  return dirent.type === DirentType.DirectoryExpanded
+}
+
+const getPath = (dirent) => {
+  return dirent.path
+}
+
+const getSavedChildDirents = (map, path, depth) => {
+  const children = map[path]
+  if (!children) {
+    return []
+  }
+  const dirents = []
+  children.sort(compareDirent)
+  const childrenLength = children.length
+  for (let i = 0; i < childrenLength; i++) {
+    const child = children[i]
+    const { name, type } = child
+    const childPath = path + '/' + name
+
+    if (child.type === DirentType.Directory && childPath in map) {
+      dirents.push({
+        depth,
+        posInSet: i + 1,
+        setSize: childrenLength,
+        icon: IconTheme.getFolderIcon({ name }),
+        name,
+        path: childPath,
+        type: DirentType.DirectoryExpanded,
+      })
+      dirents.push(...getSavedChildDirents(map, childPath, depth + 1))
+    } else {
+      dirents.push({
+        depth,
+        posInSet: i + 1,
+        setSize: childrenLength,
+        icon: IconTheme.getIcon({ type, name }),
+        name,
+        path: childPath,
+        type,
+      })
+    }
+  }
+  return dirents
+}
+
+const createDirents = (root, expandedDirentPaths, expandedDirentChildren) => {
+  const dirents = []
+  const map = Object.create(null)
+  for (let i = 0; i < expandedDirentPaths.length; i++) {
+    const path = expandedDirentPaths[i]
+    const children = expandedDirentChildren[i]
+    if (children.status === PromiseStatus.Fulfilled) {
+      map[path] = children.value
+    }
+  }
+  dirents.push(...getSavedChildDirents(map, root, 1))
+  return dirents
+}
+
+const restoreExpandedState = async (savedState, root, pathSeparator) => {
+  // TODO read all opened folders in parallel
+  // ignore ENOENT errors
+  // ignore ENOTDIR errors
+  // merge all dirents
+  // restore scroll location
+  if (!savedState || !savedState.expandedPaths) {
+    return await getTopLevelDirents(root, pathSeparator)
+  }
+  const expandedDirentPaths = [root, ...savedState.expandedPaths]
+  const expandedDirentChildren = await Promise.allSettled(
+    expandedDirentPaths.map(FileSystem.readDirWithFileTypes)
+  )
+  const savedRoot = savedState.root
+  const dirents = createDirents(
+    savedRoot,
+    expandedDirentPaths,
+    expandedDirentChildren
+  )
+  return dirents
+}
+
+export const saveState = (state) => {
+  const { dirents, root } = state
+  const expandedPaths = dirents.filter(isExpandedDirectory).map(getPath)
+  return {
+    expandedPaths,
+    root,
+  }
+}
+
+export const loadContent = async (state, savedState) => {
+  const root = state.root || Workspace.state.workspacePath
+  // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root) // TODO only load path separator once
-  const dirents = await getTopLevelDirents(root, pathSeparator)
+  const restoredDirents = await restoreExpandedState(
+    savedState,
+    root,
+    pathSeparator
+  )
   const { itemHeight, height } = state
   return {
     ...state,
     root,
-    dirents,
+    dirents: restoredDirents,
     maxLineY: Math.round(height / itemHeight),
     pathSeparator,
   }
@@ -1150,7 +1247,6 @@ export const shouldApplyNewState = (newState, fn) => {
 export const events = {
   'languages.changed': handleLanguagesChanged,
   'workspace.change': handleWorkspaceChange,
-  'iconTheme.change': handleIconThemeChange,
 }
 
 export const hasFunctionalRender = true

package/static/18087fa/packages/renderer-worker/src/parts/ViewletExtensionDetail/ViewletExtensionDetail.ipc.js

@@ -0,0 +1,9 @@
+import * as ViewletExtensionDetail from './ViewletExtensionDetail.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'ExtensionDetail.handleIconError':  Viewlet.wrapViewletCommand('ExtensionDetail', ViewletExtensionDetail.handleIconError)
+}
+
+export * from './ViewletExtensionDetail.js'

package/static/18087fa/packages/renderer-worker/src/parts/ViewletExtensionDetail/ViewletExtensionDetail.js

@@ -0,0 +1,115 @@
+import * as ExtensionDisplay from '../ExtensionDisplay/ExtensionDisplay.js'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as MarkDown from '../Markdown/Markdown.js'
+import * as Path from '../Path/Path.js'
+import * as SanitizeHtml from '../SanitizeHtml/SanitizeHtml.js'
+
+export const name = 'ExtensionDetail'
+
+export const create = (id, uri) => {
+  return {
+    name: '',
+    uri,
+  }
+}
+
+const loadReadmeContent = async (path) => {
+  const readmeUrl = Path.join('/', path, 'README.md')
+  const readmeContent = await FileSystem.readFile(readmeUrl)
+  return readmeContent
+}
+
+const DEFAULT_ICON_SRC = '/icons/extensionDefaultIcon.png'
+const DEFAULT_ICON_LANGUAGE_BASICS = '/icons/language-icon.svg'
+const DEFAULT_ICON_THEME = '/icons/theme-icon.png'
+
+// TODO duplicate code with viewletExtensions
+const getIconSrc = (extension) => {
+  if (extension.icon) {
+    return ExtensionDisplay.getIcon(extension)
+  }
+  if (extension.name && extension.name.startsWith('Language Basics')) {
+    return DEFAULT_ICON_LANGUAGE_BASICS
+  }
+  if (extension.name && extension.name.endsWith(' Theme')) {
+    return DEFAULT_ICON_THEME
+  }
+  return DEFAULT_ICON_SRC
+}
+
+// TODO when there are multiple extension with the same id,
+// probably need to pass extension location from extensions viewlet
+export const loadContent = async (state) => {
+  const { uri } = state
+  const id = uri.slice('extension-detail://'.length)
+  const extension = await ExtensionManagement.getExtension(id)
+  const readmeContent = await loadReadmeContent(extension.path)
+  const readmeHtml = MarkDown.toHtml(readmeContent)
+  const sanitizedReadmeHtml = await SanitizeHtml.sanitizeHtml(readmeHtml)
+  const iconSrc = getIconSrc(extension)
+  const name = ExtensionDisplay.getName(extension)
+  return {
+    ...state,
+    sanitizedReadmeHtml,
+    iconSrc,
+    name,
+  }
+}
+
+export const handleIconError = (state) => {
+  const { iconSrc } = state
+  if (iconSrc === DEFAULT_ICON_SRC) {
+    return state
+  }
+  return {
+    ...state,
+    iconSrc: DEFAULT_ICON_SRC,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderName = {
+  isEqual(oldState, newState) {
+    return oldState.name === newState.name
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'ExtensionDetail',
+      /* method */ 'setName',
+      /* name */ newState.name,
+    ]
+  },
+}
+
+const renderReadme = {
+  isEqual(oldState, newState) {
+    return oldState.sanitizedReadmeHtml === newState.sanitizedReadmeHtml
+  },
+  apply(pldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'ExtensionDetail',
+      /* method */ 'setReadmeHtml',
+      /* sanizedHtml */ newState.sanitizedReadmeHtml,
+    ]
+  },
+}
+
+const renderIcon = {
+  isEqual(oldState, newState) {
+    return oldState.iconSrc === newState.iconSrc
+  },
+  apply(pldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'ExtensionDetail',
+      /* method */ 'setIconSrc',
+      /* src */ newState.iconSrc,
+    ]
+  },
+}
+
+export const render = [renderName, renderReadme, renderIcon]

package/static/{bda65b1 → 18087fa}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.ipc.js

@@ -11,6 +11,9 @@ const Imports = {
   FocusPrevious: () => import('./ViewletExtensionsFocusPrevious.js'),
   FocusPreviousPage: () => import('./ViewletExtensionsFocusPreviousPage.js'),
   HandleClick: () => import('./ViewletExtensionsHandleClick.js'),
+  HandleTouchStart: () => import('./ViewletExtensionsHandleTouchStart.js'),
+  HandleTouchEnd: () => import('./ViewletExtensionsHandleTouchEnd.js'),
+  HandleTouchMove: () => import('./ViewletExtensionsHandleTouchMove.js'),
 }
 
 // prettier-ignore
@@ -29,6 +32,9 @@ export const Commands = {
   'Extensions.handleInstall': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleInstall),
   'Extensions.handleScrollBarClick': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleScrollBarClick),
   'Extensions.handleScrollBarMove': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleScrollBarMove),
+  'Extensions.handleTouchEnd':LazyCommand.create('Extensions', Imports.HandleTouchEnd, 'handleTouchEnd'),
+  'Extensions.handleTouchMove':LazyCommand.create('Extensions', Imports.HandleTouchMove, 'handleTouchMove'),
+  'Extensions.handleTouchStart': LazyCommand.create('Extensions', Imports.HandleTouchStart, 'handleTouchStart'),
   'Extensions.handleUninstall': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleUninstall),
   'Extensions.handleWheel': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.handleWheel),
   'Extensions.openSuggest': Viewlet.wrapViewletCommand('Extensions', ViewletExtensions.openSuggest),

package/static/{bda65b1 → 18087fa}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.js

@@ -1,9 +1,10 @@
+import * as Assert from '../Assert/Assert.js'
 import * as Command from '../Command/Command.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
+import * as ExtensionDisplay from '../ExtensionDisplay/ExtensionDisplay.js'
 import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js' // TODO use Command.execute instead
 import * as ExtensionsMarketplace from '../ExtensionMarketplace/ExtensionMarketplace.js'
-import * as Platform from '../Platform/Platform.js'
-import * as Assert from '../Assert/Assert.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import {
   getListHeight,
@@ -11,7 +12,7 @@ import {
   ITEM_HEIGHT,
   MINIMUM_SLIDER_SIZE,
 } from './ViewletExtensionsShared.js'
-import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
+
 const SUGGESTIONS = [
   '@builtin',
   '@disabled',
@@ -51,6 +52,9 @@ export const create = (id, uri, left, top, width, height) => {
     left,
     finalDeltaY: 2728,
     error: '',
+    touchOffsetY: 0,
+    touchTimeStamp: 0,
+    touchDifference: 0,
   }
 }
 
@@ -73,7 +77,6 @@ export const loadContent = async (state) => {
   const contentHeight = viewObjects.length * ITEM_HEIGHT
   const scrollBarHeight = getScrollBarHeight(state.height, contentHeight)
 
-  console.log({ scrollBarHeight })
   return {
     ...state,
     extensions,
@@ -104,77 +107,17 @@ export const contentLoaded = async (state) => {
   // )
 }
 
-const RE_PUBLISHER = /^[a-z\d\-]+/
-
-// TODO handle case when extension is of type number|array|null|string
-const getPublisher = (extension) => {
-  if (!extension || !extension.id) {
-    return 'n/a'
-  }
-  // TODO handle case when id is not of type string -> should not crash application
-  const match = extension.id.match(RE_PUBLISHER)
-  if (!match) {
-    return 'n/a'
-  }
-  return match[0]
-}
-
-// TODO all icon related logic should be here, not in renderer process
-const getIcon = (extension) => {
-  if (!extension || !extension.path || !extension.icon) {
-    return ''
-  }
-  if (Platform.platform === 'remote') {
-    return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
-  }
-  if (Platform.platform === 'electron') {
-    return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
-  }
-  return ''
-}
-
-const getName = (extension) => {
-  if (extension && extension.name) {
-    return extension.name
-  }
-  if (extension && extension.id) {
-    return extension.id
-  }
-  return 'n/a'
-}
-
-const getVersion = (extension) => {
-  if (!extension || !extension.version) {
-    return 'n/a'
-  }
-  return extension.version
-}
-
-const getDescription = (extension) => {
-  if (!extension || !extension.description) {
-    return 'n/a'
-  }
-  return extension.description
-}
-
-const getId = (extension) => {
-  if (!extension || !extension.id) {
-    return 'n/a'
-  }
-  return extension.id
-}
-
 const toInstalledViewObject = (extension) => {
   return {
-    name: getName(extension),
-    publisher: getPublisher(extension),
-    version: getVersion(extension),
-    description: getDescription(extension),
+    name: ExtensionDisplay.getName(extension),
+    publisher: ExtensionDisplay.getPublisher(extension),
+    version: ExtensionDisplay.getVersion(extension),
+    description: ExtensionDisplay.getDescription(extension),
     // TODO type field: builtin|marketplace|external
     // TODO should be status
     state: 'installed',
-    id: getId(extension),
-    icon: getIcon(extension),
+    id: ExtensionDisplay.getId(extension),
+    icon: ExtensionDisplay.getIcon(extension),
   }
 }
 
@@ -512,7 +455,6 @@ export const resize = (state, dimensions) => {
 }
 
 export const setDeltaY = (state, deltaY) => {
-  console.log({ deltaY })
   Assert.object(state)
   Assert.number(deltaY)
   const listHeight = getListHeight(state)
@@ -569,10 +511,8 @@ const getNewPercent = (state, relativeY) => {
 
 export const handleScrollBarMove = (state, y) => {
   const relativeY = y - state.top - HEADER_HEIGHT - state.handleOffset
-  console.log('handle offset', state.handleOffset)
   const newPercent = getNewPercent(state, relativeY)
   const newDeltaY = newPercent * state.finalDeltaY
-  console.log({ relativeY, newPercent, newDeltaY })
   return setDeltaY(state, newDeltaY)
 }
 
@@ -595,12 +535,6 @@ const getNewDeltaPercent = (state, relativeY) => {
 export const handleScrollBarClick = (state, y) => {
   const relativeY = y - state.top - HEADER_HEIGHT
   const newPercent = getNewDeltaPercent(state, relativeY)
-  console.log({
-    relativeY,
-    top: state.top,
-    headerHeight: HEADER_HEIGHT,
-    newPercent,
-  })
   const newDeltaY = newPercent * state.finalDeltaY
 
   return {

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

@@ -0,0 +1,11 @@
+import { focusIndex } from './ViewletExtensionsFocusIndex.js'
+import * as Command from '../Command/Command.js'
+
+export const handleClick = async (state, index) => {
+  const { filteredExtensions, minLineY } = state
+  const actualIndex = index + minLineY
+  const extension = filteredExtensions[actualIndex]
+  const uri = `extension-detail://${extension.id}`
+  await Command.execute('Main.openUri', uri)
+  return focusIndex(state, actualIndex)
+}