@lvce-editor/server 0.0.28 → 0.0.31

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

@@ -1,113 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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/Editor/Editor.js

@@ -1,351 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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
-}