@lvce-editor/server 0.0.28 → 0.0.31

package/static/f9b8874/packages/renderer-worker/src/parts/Viewlet/ViewletEditorCompletion.js

@@ -1,243 +0,0 @@
-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) => {
-  // Editor.sync(editor)
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  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 x = EditorPosition.x(editor, editor.cursor)
-  const y = EditorPosition.y(editor, editor.cursor)
-  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,
-    /* position */ { rowIndex: 0, columnIndex: 0 },
-    /* message */ displayErrorMessage,
-    /* isError */ true
-  )
-}
-
-export const loadingContent = () => {
-  const editor = getEditor()
-  console.log('show loading')
-  const x = EditorPosition.x(editor, editor.cursor)
-  const y = EditorPosition.y(editor, editor.cursor)
-  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 hasFunctionalRender = true
-
-export const render = (oldState, newState) => {
-  const changes = []
-  if (oldState.x !== newState.x || oldState.y !== newState.y) {
-    changes.push([
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'EditorCompletion',
-      /* method */ 'setPosition',
-      /* x */ newState.x,
-      /* y */ newState.y,
-    ])
-  }
-  if (oldState.visibleItems !== newState.visibleItems) {
-    changes.push([
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'EditorCompletion',
-      /* method */ 'setItems',
-      /* items */ newState.visibleItems,
-      /* reason */ 1,
-    ])
-  }
-  console.log({ changes })
-  return changes
-}
-
-export const dispose = (state) => {
-  return {
-    ...state,
-    disposed: true,
-  }
-}

package/static/f9b8874/packages/renderer-worker/src/parts/Viewlet/ViewletEditorImage.js

@@ -1,39 +0,0 @@
-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
-
-export const render = (oldState, newState) => {
-  const changes = []
-  if (oldState.src !== newState.src) {
-    changes.push([
-      /* Viewlet.invoke */ 'Viewlet.send',
-      /* id */ 'EditorImage',
-      /* method */ 'setSrc',
-      /* src */ `/remote${newState.src}`,
-    ])
-  }
-  return changes
-}

package/static/f9b8874/packages/renderer-worker/src/parts/Viewlet/ViewletEditorPlainText.js

@@ -1,43 +0,0 @@
-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
-
-export const render = (oldState, newState) => {
-  const changes = []
-  if (oldState.content !== newState.content) {
-    changes.push([
-      /* Viewlet.invoke */ 'Viewlet.send',
-      /* id */ 'EditorPlainText',
-      /* method */ 'setContent',
-      /* content */ newState.content,
-    ])
-  }
-  return changes
-}

package/static/f9b8874/packages/renderer-worker/src/parts/Viewlet/ViewletEditorText.js

@@ -1,169 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Editor from '../Editor/Editor.js'
-import * as ExtensionHostSemanticTokens from '../ExtensionHost/ExtensionHostSemanticTokens.js'
-// import * as ExtensionHostTextDocument from '../ExtensionHost/ExtensionHostTextDocument.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Languages from '../Languages/Languages.js'
-import * as Preferences from '../Preferences/Preferences.js'
-import * as Tokenizer from '../Tokenizer/Tokenizer.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as Id from '../Id/Id.js'
-
-const COLUMN_WIDTH = 9 // TODO compute this automatically once
-
-const getContent = async (uri) => {
-  const content = await FileSystem.readFile(uri)
-  return content ?? 'content could not be loaded'
-}
-
-// TODO how to connect this function with tokenizer?
-const handleTokenizeChange = () => {
-  const instances = Viewlet.state.instances
-  const instance = instances.EditorText
-  if (!instance) {
-    console.log('no text editor')
-    return
-  }
-  const state = instance.state
-  const tokenizer = Tokenizer.getTokenizer(state.languageId)
-  const newState = {
-    ...instance.state,
-    tokenizer,
-  }
-  Viewlet.setState('EditorText', newState)
-}
-
-// TODO uri?
-export const create = (id, uri, left, top, width, height) => {
-  console.log({ id })
-  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)
-  return {
-    ...newState,
-    uri,
-    rowHeight: 20,
-    languageId,
-  }
-}
-
-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 tokenizer = Tokenizer.getTokenizer(languageId)
-  const content = await getContent(state.uri)
-  const newState = Editor.setText(state, content)
-  return {
-    ...newState,
-    rowHeight,
-    fontSize,
-    letterSpacing,
-    tokenizer,
-  }
-}
-
-export const contentLoaded = async (state) => {
-  // Editor.renderText(state)
-}
-
-const updateSemanticTokens = async (state) => {
-  try {
-    const newSemanticTokens =
-      await ExtensionHostSemanticTokens.executeSemanticTokenProvider(state)
-    await Command.execute(
-      /* Editor.setDecorations */ 'Editor.setDecorations',
-      /* decorations */ newSemanticTokens
-    )
-    // TODO apply semantic tokens to editor and rerender
-    // TODO possibly overlay semantic tokens as decorations
-  } catch (error) {
-    if (
-      error &&
-      error instanceof Error &&
-      error.message.startsWith(
-        'Failed to execute semantic token provider: VError: no semantic token provider found for'
-      )
-    ) {
-      return
-    }
-    console.error(error)
-  }
-}
-
-const handleEditorChange = async (editor, changes) => {
-  // await ExtensionHostTextDocument.handleEditorChange(editor, changes)
-  // TODO check if semantic highlighting is enabled in settings
-  await updateSemanticTokens(editor)
-}
-
-export const contentLoadedEffects = async (state) => {
-  // TODO dispose listener
-  // TODO don't like side effect here, where to put it?
-  GlobalEventBus.addListener('languages.changed', handleLanguagesChanged)
-  GlobalEventBus.addListener('tokenizer.changed', handleTokenizeChange)
-  GlobalEventBus.addListener('editor.change', handleEditorChange)
-  const newLanguageId = Languages.getLanguageId(state.uri)
-  await Command.execute(
-    /* Editor.setLanguageId */ 'Editor.setLanguageId',
-    /* languageId */ newLanguageId
-  )
-  // await ExtensionHostTextDocument.handleEditorCreate(state)
-  // TODO check if semantic highlighting is enabled in settings
-  await updateSemanticTokens(state)
-  GlobalEventBus.emitEvent('editor.create', state)
-}
-
-const handleLanguagesChanged = async () => {
-  const instances = Viewlet.state.instances
-  const instance = instances.EditorText
-  if (!instance) {
-    console.log('no text editor')
-    return
-  }
-  const state = instance.state
-  const newLanguageId = Languages.getLanguageId(state.uri)
-  state.languageId = newLanguageId
-  // await ExtensionHostTextDocument.handleEditorLanguageChange(state)
-  // if (state.languageId === newLanguageId) {
-  //   return
-  // }
-  // await Promise.all([
-  //   Editor.setLanguageId(state, newLanguageId),
-  // ])
-  await Command.execute(
-    /* Editor.setLanguageId */ 'Editor.setLanguageId',
-    /* languageId */ newLanguageId
-  )
-
-  const newEditor = instances.EditorText.state
-  console.log({ newEditor })
-
-  GlobalEventBus.emitEvent('editor.languageChange', newEditor, newLanguageId)
-  // console.log({ state })
-}
-
-export const resize = (state, dimensions) => {
-  const newState = Editor.setBounds(
-    state,
-    dimensions.top,
-    dimensions.left,
-    dimensions.height,
-    state.columnWidth
-  )
-  const commands = [Editor.renderTextAndCursorAndSelectionsCommands(newState)]
-  return {
-    newState,
-    commands,
-  }
-}
-
-export const hasFunctionalRender = true
-
-export const render = (oldState, newState) => {
-  console.log({ oldState, newState })
-  return Editor.render(oldState, newState)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/Viewlet/ViewletExplorer.ipc.js

@@ -1,41 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ViewletExplorer from './ViewletExplorer.js'
-import * as Viewlet from './Viewlet.js'
-
-// prettier-ignore
-export const __initialize__ = () => {
-  Command.register('Explorer.acceptNewFile',        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.acceptNewFile))
-  Command.register('Explorer.acceptRename',         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.acceptRename))
-  Command.register('Explorer.cancelNewFile',        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.cancelNewFile))
-  Command.register('Explorer.cancelRename',         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.cancelRename))
-  Command.register('Explorer.collapseAll',          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.collapseAll))
-  Command.register('Explorer.copyPath',             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyPath))
-  Command.register('Explorer.copyRelativePath',     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyRelativePath))
-  Command.register('Explorer.expandAll',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.expandAll))
-  Command.register('Explorer.focusFirst',           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusFirst))
-  Command.register('Explorer.focusIndex',           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusIndex))
-  Command.register('Explorer.focusLast',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusLast))
-  Command.register('Explorer.focusNext',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNext))
-  Command.register('Explorer.focusNone',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNone))
-  Command.register('Explorer.focusPrevious',        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusPrevious))
-  Command.register('Explorer.getFocusedDirent',     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.getFocusedDirent))
-  Command.register('Explorer.handleArrowLeft',      Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowLeft))
-  Command.register('Explorer.handleArrowRight',     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowRight))
-  Command.register('Explorer.handleBlur',           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleBlur))
-  Command.register('Explorer.handleClick',          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClick))
-  Command.register('Explorer.handleClickCurrent',   Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClickCurrent))
-  Command.register('Explorer.handleContextMenu',    Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleContextMenu))
-  Command.register('Explorer.handleCopy',           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleCopy))
-  Command.register('Explorer.handleMouseEnter',     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseEnter))
-  Command.register('Explorer.handleMouseLeave',     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseLeave))
-  Command.register('Explorer.handlePaste',          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handlePaste))
-  Command.register('Explorer.handleWheel',          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleWheel))
-  Command.register('Explorer.newFile',              Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFile))
-  Command.register('Explorer.newFolder',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFolder))
-  Command.register('Explorer.openContainingFolder', Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.openContainingFolder))
-  Command.register('Explorer.removeDirent',         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.removeDirent))
-  Command.register('Explorer.renameDirent',         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.renameDirent))
-  Command.register('Explorer.scrollDown',           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.scrollDown))
-  Command.register('Explorer.scrollUp',             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.scrollUp))
-  Command.register('Explorer.setDeltaY',            Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.setDeltaY))
-}