@lvce-editor/server 0.0.27 → 0.0.28

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

@@ -0,0 +1,113 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const state = {
+  dialog: undefined,
+}
+
+export const openFolder = async () => {
+  if (Platform.getPlatform() === 'web') {
+    console.warn('open folder - not implemented')
+    return
+  }
+  if (Platform.getPlatform() === 'remote') {
+    const path = await RendererProcess.invoke(
+      /* Dialog.prompt */ 7833,
+      /* message */ 'Choose path:'
+    )
+    await Command.execute(
+      /* Workspace.setPath */ 'Workspace.setPath',
+      /* path */ path
+    )
+    return
+  }
+  const folders = await SharedProcess.invoke(
+    /* Electron.showOpenDialog */ 'Electron.showOpenDialog'
+  )
+  if (!folders || folders.length === 0) {
+    return
+  }
+  const path = folders[0]
+  await Command.execute(
+    /* Workspace.setPath */ 'Workspace.setPath',
+    /* path */ path
+  )
+}
+
+export const showAbout = async () => {
+  if (Platform.getPlatform() === 'web' || Platform.getPlatform() === 'remote') {
+    console.warn('show about - not implemented')
+    return
+  }
+  await SharedProcess.invoke(/* Electron.about */ 'Electron.about')
+}
+
+export const showMessage = async (message, options) => {
+  if (state.dialog) {
+    console.info('cannot show multiple dialogs at the same time')
+    return
+  }
+  // TODO implement actual dialog component for web
+  // RendererProcess.invoke(/* Dialog.alert */ 7834, /* message */ message)
+  // TODO on electron use native dialog
+  if (!options) {
+    options = ['Show Command Output', 'Cancel', 'Open Git Log']
+  }
+  // @ts-ignore
+  state.dialog = {
+    message,
+    options,
+  }
+
+  if (Platform.getPlatform() === 'electron') {
+    const index = await SharedProcess.invoke(
+      /* Electron.showMessageBox */ 'Electron.showMessageBox',
+      /* message */ message.message,
+      /* buttons */ options
+    )
+
+    if (index === -1) {
+      // TODO can this even happen?
+      return
+    }
+    await handleClick(index)
+    // console.log({ result: index })
+    // state.dialog = undefined
+  } else {
+    await RendererProcess.invoke(
+      /* Dialog.showErrorDialogWithOptions */ 'Dialog.showErrorDialogWithOptions',
+      /* message */ message,
+      /* options */ options
+    )
+  }
+}
+
+export const close = async () => {
+  // TODO support closing of electron dialogs
+  if (!state.dialog) {
+    console.info('no dialog to close')
+    return
+  }
+  state.dialog = undefined
+  await RendererProcess.invoke(/* Dialog.close */ 7836)
+}
+
+export const handleClick = async (index) => {
+  const dialog = state.dialog
+  const option = dialog.options[index]
+  // TODO handle case when index is out of bounds
+  console.log({ option })
+  switch (option) {
+    case 'Show Command Output':
+      await close()
+      const uri = `data://${dialog.message.stderr}`
+      await Command.execute(/* Main.openUri */ 'Main.openUri', uri)
+      // TODO show stderr in editor
+      // TODO close dialog
+      break
+    default:
+      break
+  }
+}

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

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Download from './Download.js'
+
+export const __initialize__ = () => {
+  Command.register('Download.downloadFile', Download.downloadFile)
+  Command.register('Download.downloadJson', Download.downloadJson)
+}

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

@@ -0,0 +1,31 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Assert from '../Assert/Assert.js'
+
+export const downloadFile = async (fileName, url) => {
+  Assert.string(fileName)
+  Assert.string(url)
+  await RendererProcess.invoke(
+    /* Download.DownloadFile */ 'Download.downloadFile',
+    /* fileName */ fileName,
+    /* url */ url
+  )
+}
+
+export const downloadJson = async (json, fileName) => {
+  let url = ''
+  try {
+    const stringified = JSON.stringify(json, null, 2)
+    const blob = new Blob([stringified], {
+      type: 'application/json',
+    })
+    url = URL.createObjectURL(blob)
+    await downloadFile(fileName, url)
+  } catch (error) {
+    throw new Error(`Failed to download ${fileName}`, {
+      // @ts-ignore
+      cause: error,
+    })
+  } finally {
+    URL.revokeObjectURL(url)
+  }
+}

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

@@ -0,0 +1,351 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Tokenizer from '../Tokenizer/Tokenizer.js'
+import * as Assert from '../Assert/Assert.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as EditorCursor from './EditorCursor.js'
+import * as EditorScrolling from './EditorScrolling.js'
+import * as EditorSelection from './EditorSelection.js'
+import * as EditorText from './EditorText.js'
+
+const MINIMUM_SLIDER_SIZE = 20
+
+// TODO
+export const create = (id, uri, languageId, content) => {
+  const tokenizer = Tokenizer.getTokenizer(languageId)
+
+  // TODO flatten structure
+  return {
+    uri,
+    languageId,
+    lines: content.split('\n'),
+    // TODO cursor should be part of selection,
+    // codemirror has selections: Selection[]
+    //            selectionIndex: number
+    cursor: {
+      rowIndex: 0,
+      columnIndex: 0,
+    },
+    // TODO how to get the trigger characters here from extension host
+    completionTriggerCharacters: [],
+    selections: [],
+    id,
+    tokenizer,
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    numberOfVisibleLines: 0,
+    finalY: 0,
+    finalDeltaY: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    columnWidth: 0,
+    rowHeight: 0,
+    fontSize: 0, // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
+    letterSpacing: 0,
+    scrollBarHeight: 0,
+    undoStack: [],
+    // TODO maybe put these into separate tokenization module
+    lineCache: [],
+    validLines: [],
+    invalidStartIndex: 0,
+    decorations: [],
+  }
+}
+
+export const dispose = (id) => {
+  // delete state.editors[id]
+}
+
+export const renderText = (editor) => {
+  Assert.object(editor)
+  const textInfos = EditorText.getVisible(editor)
+  RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'renderText',
+    /* scrollBarY */ editor.scrollBarY,
+    /* scrollBarHeight */ editor.scrollBarHeight,
+    /* textInfos */ textInfos,
+    /* fontSize */ editor.fontSize, // TODO only send these properties once on first render
+    /* lineHeight */ editor.rowHeight,
+    /* letterSpacing */ editor.letterSpacing
+  )
+}
+
+export const renderTextAndCursorAndSelectionsCommands = (editor) => {
+  Assert.object(editor)
+  const textInfos = EditorText.getVisible(editor)
+  const cursorInfos = EditorCursor.getVisible(editor)
+  const selectionInfos = EditorSelection.getVisible(editor)
+  const scrollBarHeight = editor.scrollBarHeight
+  const scrollBarY =
+    (editor.deltaY / editor.finalDeltaY) *
+    (editor.height - editor.scrollBarHeight)
+  return [
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'renderTextAndCursorsAndSelections',
+    /* scrollBarY */ scrollBarY,
+    /* scrollBarHeight */ scrollBarHeight,
+    /* textInfos */ textInfos,
+    /* cursorInfos */ cursorInfos,
+    /* selectionInfos */ selectionInfos,
+  ]
+}
+
+export const renderTextAndCursorAndSelections = (editor) => {
+  const commands = renderTextAndCursorAndSelectionsCommands(editor)
+  RendererProcess.send(commands)
+}
+
+export const setTokenizer = (editor, tokenizer) => {
+  editor.tokenizer = Tokenizer.getTokenizer(editor.languageId)
+  editor.invalidStartIndex = 0
+}
+
+// TODO
+export const setDeltaYFixedValue = (editor, value) => {
+  return EditorScrolling.setDeltaY(editor, value)
+  // renderTextAndCursorAndSelections(editor)
+}
+
+export const setDeltaY = (editor, value) => {
+  return setDeltaYFixedValue(editor, editor.deltaY + value)
+}
+
+export const scheduleSelections = (editor, selectionEdits) => {
+  return EditorSelection.setSelections(editor, selectionEdits)
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderCursorsAndSelections',
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const scheduleSelectionsAndScrollPosition = (
+  editor,
+  selectionEdits,
+  deltaY
+) => {
+  const newEditor1 = EditorSelection.setSelections(editor, selectionEdits)
+  const newEditor2 = EditorScrolling.setDeltaY(newEditor1, deltaY)
+  return newEditor2
+  // EditorScrolling.setDeltaY(editor, deltaY)
+  // EditorSelection.setSelections(editor, selectionEdits)
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // const textInfos = EditorText.getVisible(editor)
+  // // TODO scrollbar calculation duplicate code
+  // const scrollBarY =
+  //   (editor.deltaY / editor.finalDeltaY) *
+  //   (editor.height - editor.scrollBarHeight)
+  // const scrollBarHeight = editor.scrollBarHeight
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderTextAndCursorsAndSelections',
+  //   /* deltaY */ scrollBarY,
+  //   /* scrollBarHeight */ scrollBarHeight,
+  //   /* textInfos */ textInfos,
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const scheduleDocumentAndCursorsSelections = (editor, changes) => {
+  Assert.object(editor)
+  Assert.array(changes)
+  if (changes.length === 0) {
+    return editor
+  }
+  const newLines = TextDocument.applyEdits(editor, changes)
+  const partialNewEditor = {
+    ...editor,
+    lines: newLines,
+  }
+  console.log({ partialNewEditor })
+  const newSelections = EditorSelection.applyEdit(partialNewEditor, changes)
+  // TODO should separate rendering from business logic somehow
+  // currently hard to test because need to mock editor height, top, left,
+  // invalidStartIndex, lineCache, etc. just for testing editorType
+  const invalidStartIndex = Math.min(
+    editor.invalidStartIndex,
+    changes[0].start.rowIndex
+  )
+
+  // TODO maybe put undostack into indexeddb so that there is no memory leak in application
+  // then clear old undostack from indexeddb after 3 days
+  // TODO should push to undostack after rendering
+
+  const newEditor = {
+    ...partialNewEditor,
+    lines: newLines,
+    selections: newSelections,
+    cursor: newSelections[0].end,
+    undoStack: [...editor.undoStack, changes],
+    invalidStartIndex,
+  }
+  GlobalEventBus.emitEvent('editor.change', newEditor, changes)
+
+  return newEditor
+  // const textInfos = EditorText.getVisible(editor)
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+
+  // if (editor.undoStack) {
+  //   editor.undoStack.push(changes)
+  // }
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderTextAndCursorsAndSelections',
+  //   /* deltaY */ editor.deltaY,
+  //   /* scrollBarHeight */ editor.scrollBarHeight,
+  //   /* textInfos */ textInfos,
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const scheduleDocument = async (editor, changes) => {
+  // console.log('before')
+  // console.log([...editor.lines])
+  const newLines = TextDocument.applyEdits(editor, changes)
+  // console.log('after')
+  // console.log([...editor.lines])
+  const invalidStartIndex = changes[0].start.rowIndex
+  // if (editor.undoStack) {
+  //   editor.undoStack.push(changes)
+  // }
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // const textInfos = EditorText.getVisible(editor)
+  // TODO scrollbar calculation duplicate code
+  // const scrollBarY =
+  //   (editor.deltaY / editor.finalDeltaY) *
+  //   (editor.height - editor.scrollBarHeight)
+  // const scrollBarHeight = editor.scrollBarHeight
+
+  const newEditor = {
+    ...editor,
+    undoStack: [...editor.undoStack, changes],
+    lines: newLines,
+    invalidStartIndex,
+  }
+  // TODO change event should be emitted after rendering
+  GlobalEventBus.emitEvent('editor.change', editor, changes)
+  return newEditor
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderTextAndCursorsAndSelections',
+  //   /* deltaY */ scrollBarY,
+  //   /* scrollBarHeight */ scrollBarHeight,
+  //   /* textInfos */ textInfos,
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const hasSelection = (editor) => {
+  // TODO editor.selections should always be defined
+  return editor.selections && editor.selections.length > 0
+}
+
+export const setBounds = (editor, top, left, height, columnWidth) => {
+  const numberOfVisibleLines = Math.floor(height / 20)
+  const maxLineY = Math.min(numberOfVisibleLines, editor.lines.length)
+  const finalY = Math.max(editor.lines.length - numberOfVisibleLines, 0)
+  const finalDeltaY = finalY * 20
+  return {
+    ...editor,
+    top,
+    left,
+    height,
+    columnWidth,
+    numberOfVisibleLines,
+    maxLineY,
+    finalY,
+    finalDeltaY,
+  }
+}
+
+const getScrollBarHeight = (editorHeight, contentHeight) => {
+  if (editorHeight > contentHeight) {
+    return 0
+  }
+  return Math.max(
+    Math.round(editorHeight ** 2 / contentHeight),
+    MINIMUM_SLIDER_SIZE
+  )
+}
+
+export const setText = (editor, text) => {
+  const lines = text.split('\n')
+  const maxLineY = Math.min(editor.numberOfVisibleLines, lines.length)
+  const finalY = Math.max(lines.length - editor.numberOfVisibleLines, 0)
+  const finalDeltaY = finalY * 20
+  const contentHeight = lines.length * editor.rowHeight
+  const scrollBarHeight = getScrollBarHeight(editor.height, contentHeight)
+  return {
+    ...editor,
+    lines,
+    maxLineY,
+    finalY,
+    finalDeltaY,
+    scrollBarHeight,
+  }
+}
+
+export const render = (oldState, newState) => {
+  const changes = []
+  if (
+    oldState.lines !== newState.lines ||
+    oldState.tokenizer !== newState.tokenizer ||
+    oldState.minLineY !== newState.minLineY ||
+    oldState.decorations !== newState.decorations
+  ) {
+    const textInfos = EditorText.getVisible(newState)
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorText',
+      /* method */ 'setText',
+      /* textInfos */ textInfos,
+    ])
+  }
+
+  if (oldState.selections !== newState.selections) {
+    const cursorInfos = EditorCursor.getVisible(newState)
+    const selectionInfos = EditorSelection.getVisible(newState)
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorText',
+      /* method */ 'setSelections',
+      /* cursorInfos */ cursorInfos,
+      /* selectionInfos */ selectionInfos,
+    ])
+  }
+  if (
+    oldState.deltaY !== newState.deltaY ||
+    oldState.scrollBarHeight !== newState.scrollBarHeight
+  ) {
+    const scrollBarY =
+      (newState.deltaY / newState.finalDeltaY) *
+      (newState.height - newState.scrollBarHeight)
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorText',
+      /* method */ 'setScrollBar',
+      /* scrollBarY */ scrollBarY,
+      /* scrollBarHeight */ newState.scrollBarHeight,
+    ])
+  }
+
+  return changes
+}

package/static/f9b8874/packages/renderer-worker/src/parts/Editor/EditorCursor.js

@@ -0,0 +1,72 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Platform from '../Platform/Platform.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+
+export const applyEdits = (editor, cursor) => {
+  // TODO multiple cursors
+  console.assert(cursor)
+  editor.cursor = cursor
+  GlobalEventBus.emitEvent('editor.cursorChange', editor, cursor)
+}
+
+const isInRange = (position, min, max) => {
+  return position.rowIndex >= min && position.rowIndex <= max
+}
+
+const getTokenIndex = (lineCache, selection) => {
+  if (!lineCache) {
+    // throw new Error('no line cache found')
+    return -1
+  }
+  Assert.object(selection)
+  let offset = 0
+  for (let i = 0; i < lineCache.tokens.length; i++) {
+    const newOffset = offset + lineCache.tokens[i].length
+    if (newOffset >= selection.end.columnIndex) {
+      return {
+        index: i,
+        offset: selection.end.columnIndex - offset,
+      }
+    }
+    offset = newOffset
+  }
+  console.warn(`token at columnIndex ${selection.end.columnIndex} not found`)
+  return {
+    index: -1,
+    offset: -1,
+  }
+}
+
+export const getVisible = (editor) => {
+  if (Platform.isMobileOrTablet()) {
+    const visibleCursors = []
+    for (const selection of editor.selections) {
+      if (isInRange(selection.end, editor.minLineY, editor.maxLineY)) {
+        visibleCursors.push({
+          rowIndex: selection.end.rowIndex - editor.minLineY,
+          columnIndex: selection.end.columnIndex,
+        })
+      } else {}
+    }
+    return visibleCursors
+  }
+  // TODO could use uint16array here
+  // TODO handle case when text segmenter not supported
+  const visibleCursors = []
+  for (const selection of editor.selections) {
+    if (isInRange(selection.end, editor.minLineY, editor.maxLineY)) {
+      const lineCache = editor.lineCache[selection.end.rowIndex + 1]
+      if (!lineCache) {
+        console.log('line caches', editor, editor.lineCache)
+      }
+      const tokenIndex = getTokenIndex(lineCache, selection)
+      visibleCursors.push({
+        top: (selection.end.rowIndex - editor.minLineY) * editor.rowHeight,
+        topIndex: selection.end.rowIndex - editor.minLineY,
+        leftIndex: tokenIndex.index,
+        remainingOffset: tokenIndex.offset,
+      })
+    }
+  }
+  return visibleCursors
+}

package/static/f9b8874/packages/renderer-worker/src/parts/Editor/EditorSelection.js

@@ -0,0 +1,126 @@
+import * as Assert from '../Assert/Assert.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+
+const getSelectionFromChange = (change) => {
+  if (change.inserted.length === 1) {
+    const newPosition = {
+      rowIndex: change.start.rowIndex + change.inserted.length - 1,
+      columnIndex: change.inserted.at(-1).length + change.start.columnIndex,
+    }
+    return {
+      start: newPosition,
+      end: newPosition,
+    }
+  }
+  const newPosition = {
+    rowIndex: change.start.rowIndex + change.inserted.length - 1,
+    columnIndex: change.inserted.at(-1).length,
+  }
+  return {
+    start: newPosition,
+    end: newPosition,
+  }
+}
+
+export const setSelections = (editor, selections) => {
+  Assert.object(editor)
+  Assert.array(selections)
+  return {
+    ...editor,
+    selections,
+    cursor: selections[0].end,
+  }
+  // editor.selections = selections
+  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
+}
+
+// TODO maybe only accept sorted selection edits in the first place
+export const applyEdit = (editor, changes) => {
+  Assert.object(editor)
+  Assert.array(changes)
+  const newSelections = changes.map(getSelectionFromChange)
+  // setSelections(editor, newSelections)
+  return newSelections
+}
+
+// TODO visible selections could also be uint16array
+// [top1, left1, width1, height1, top2, left2, width2, height2...]
+
+export const getVisible = (editor) => {
+  const visibleSelections = []
+  // let i=0
+  // // TODO binary search
+
+  // // before
+  // while(i < editor.selections.length){
+  //   if(editor.selections[i].start.rowIndex < editor.minLineY){
+  //     break
+  //   }
+  //   i++
+  // }
+  // // start
+  // while(i < editor.selections.length){
+  //   if(editor.selections[i].start.rowIndex < ){
+
+  //   }
+  // }
+  // // middle
+
+  // // end
+
+  // // after
+  for (const selection of editor.selections) {
+    if (selection.end.rowIndex < editor.minLineY) {
+      continue
+    }
+    if (selection.start.rowIndex > editor.maxLineY) {
+      break
+    }
+    if (selection.start === selection.end) {
+      continue
+    }
+    if (selection.start.rowIndex === selection.end.rowIndex) {
+      visibleSelections.push({
+        top: (selection.start.rowIndex - editor.minLineY) * editor.rowHeight,
+        left: selection.start.columnIndex * editor.columnWidth,
+        width:
+          (selection.end.columnIndex - selection.start.columnIndex) *
+          editor.columnWidth,
+        height: editor.rowHeight,
+      })
+    } else {
+      if (selection.start.rowIndex >= editor.minLineY) {
+        visibleSelections.push({
+          top: (selection.start.rowIndex - editor.minLineY) * editor.rowHeight,
+          left: selection.start.columnIndex * editor.columnWidth,
+          width:
+            (editor.lines[selection.start.rowIndex].length -
+              selection.start.columnIndex) *
+            editor.columnWidth,
+          height: editor.rowHeight,
+        })
+      }
+      for (
+        let i = Math.max(selection.start.rowIndex + 1, editor.minLineY);
+        i < Math.min(selection.end.rowIndex, editor.maxLineY);
+        i++
+      ) {
+        visibleSelections.push({
+          top: (i - editor.minLineY) * editor.rowHeight,
+          left: 0,
+          width: editor.lines[i].length * editor.columnWidth,
+          height: editor.rowHeight,
+        })
+      }
+      if (selection.end.rowIndex <= editor.maxLineY) {
+        visibleSelections.push({
+          top: (selection.end.rowIndex - editor.minLineY) * editor.rowHeight,
+          left: 0,
+          width: selection.end.columnIndex * editor.columnWidth,
+          height: editor.rowHeight,
+        })
+      }
+    }
+  }
+  return visibleSelections
+}