@lvce-editor/server 0.11.12 → 0.12.0

package/static/269a2be/packages/renderer-worker/src/parts/Assert/Assert.js

@@ -1,86 +0,0 @@
-// TODO treeshake out this whole module in production
-
-const getType = (value) => {
-  switch (typeof value) {
-    case 'number':
-      return 'number'
-    case 'function':
-      return 'function'
-    case 'string':
-      return 'string'
-    case 'object':
-      if (value === null) {
-        return 'null'
-      }
-      if (Array.isArray(value)) {
-        return 'array'
-      }
-      if (value instanceof Uint32Array) {
-        return 'uint32array'
-      }
-      return 'object'
-    case 'boolean':
-      return 'boolean'
-    default:
-      return 'unknown'
-  }
-}
-
-export const object = (value) => {
-  const type = getType(value)
-  if (type !== 'object') {
-    throw new Error('expected value to be of type object')
-  }
-}
-
-export const number = (value) => {
-  const type = getType(value)
-  if (type !== 'number') {
-    throw new Error('expected value to be of type number')
-  }
-  if (isNaN(value)) {
-    throw new Error('value is NaN')
-  }
-}
-
-export const array = (value) => {
-  const type = getType(value)
-  if (type !== 'array') {
-    throw new Error('expected value to be of type array')
-  }
-}
-
-export const string = (value) => {
-  const type = getType(value)
-  if (type !== 'string') {
-    throw new Error('expected value to be of type string')
-  }
-}
-
-export const null_ = (value) => {
-  const type = getType(value)
-  if (type !== 'null') {
-    throw new Error('expected value to be of type null')
-  }
-}
-
-export const boolean = (value) => {
-  const type = getType(value)
-  if (type !== 'boolean') {
-    throw new Error('expected value to be of type boolean')
-  }
-}
-
-export const fn = (value) => {
-  const type = getType(value)
-  if (type !== 'function') {
-    throw new Error('expected value to be of type function')
-  }
-}
-
-export const uint32array = (value) => {
-  const type = getType(value)
-  if (type !== 'uint32array') {
-    throw new Error('expected value to be of type uint32array')
-  }
-}

package/static/269a2be/packages/renderer-worker/src/parts/BlobSrc/BlobSrc.js

@@ -1,39 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Procotol from '../Protocol/Protocol.js'
-import * as GetProtocol from '../GetProtocol/GetProtocol.js'
-
-const getSrcRemote = (uri) => {
-  const src = `/remote${uri}`
-  return src
-}
-
-const getSrcWithBlobUrl = async (uri) => {
-  const content = await FileSystem.readFile(uri)
-  const mimeType = await Command.execute('Mime.getMediaMimeType', uri)
-  const blob = await Command.execute(
-    'Blob.binaryStringToBlob',
-    content,
-    mimeType
-  )
-  const dataUrl = await Command.execute('Url.createObjectUrl', blob)
-  return dataUrl
-}
-
-const canUseRemoteLoading = (uri) => {
-  const protocol = GetProtocol.getProtocol(uri)
-  return protocol === ''
-}
-
-export const getSrc = (uri) => {
-  if (canUseRemoteLoading(uri)) {
-    return getSrcRemote(uri)
-  }
-  return getSrcWithBlobUrl(uri)
-}
-
-export const disposeSrc = async (src) => {
-  if (src.startsWith(Procotol.Blob)) {
-    await Command.execute('Url.revokeObjectUrl', src)
-  }
-}

package/static/269a2be/packages/renderer-worker/src/parts/Compare/Compare.js

@@ -1,3 +0,0 @@
-export const compareString = (a, b) => {
-  return a.localeCompare(b)
-}

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

@@ -1,148 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ElectronDialog from '../ElectronDialog/ElectronDialog.js'
-import * as IsAbortError from '../IsAbortError/IsAbortError.js'
-import * as Logger from '../Logger/Logger.js'
-import * as Platform from '../Platform/Platform.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  dialog: undefined,
-}
-
-const openFolderWeb = async () => {
-  try {
-    const result = await Command.execute('FilePicker.showDirectoryPicker', {
-      startIn: 'pictures',
-      mode: 'readwrite',
-    })
-    await Command.execute('PersistentFileHandle.addHandle', result.name, result)
-    await Command.execute('Workspace.setPath', `html://${result.name}`)
-  } catch (error) {
-    if (IsAbortError.isAbortError(error)) {
-      return
-    }
-    throw new VError(error, `Failed to open folder`)
-  }
-}
-
-const openFolderRemote = async () => {
-  const path = await RendererProcess.invoke(/* Dialog.prompt */ 'Dialog.prompt', /* message */ 'Choose path:')
-  if (!path) {
-    return
-  }
-  await Command.execute(/* Workspace.setPath */ 'Workspace.setPath', /* path */ path)
-}
-
-const openFolderElectron = async () => {
-  const folders = await ElectronDialog.showOpenDialog(
-    /* title */ 'Open Folder',
-    /* properties */ ['openDirectory', 'dontAddToRecent', 'showHiddenFiles']
-  )
-  if (!folders || folders.length === 0) {
-    return
-  }
-  const path = folders[0]
-  await Command.execute(/* Workspace.setPath */ 'Workspace.setPath', /* path */ path)
-}
-
-export const openFolder = () => {
-  switch (Platform.platform) {
-    case PlatformType.Web:
-      return openFolderWeb()
-    case PlatformType.Remote:
-      return openFolderRemote()
-    case PlatformType.Electron:
-      return openFolderElectron()
-    default:
-      return
-  }
-}
-
-const openFileWeb = () => {
-  Logger.warn('open file - not implemented')
-}
-
-const openFileRemote = () => {
-  Logger.warn('open file - not implemented')
-}
-
-const openFileElectron = async () => {
-  const [file] = await ElectronDialog.showOpenDialog('Open File', ['openFile', 'dontAddToRecent', 'showHiddenFiles'])
-  await Command.execute('Main.openUri', file)
-}
-
-export const openFile = () => {
-  switch (Platform.platform) {
-    case PlatformType.Web:
-      return openFileWeb()
-    case PlatformType.Remote:
-      return openFileRemote()
-    case PlatformType.Electron:
-      return openFileElectron()
-    default:
-      return
-  }
-}
-
-export const showMessage = async (message, options) => {
-  if (state.dialog) {
-    console.info('cannot show multiple dialogs at the same time', message)
-    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.platform === 'electron') {
-    const index = await ElectronDialog.showMessageBox(/* message */ message.message, /* buttons */ options)
-
-    if (index === -1) {
-      // TODO can this even happen?
-      return
-    }
-    await handleClick(index)
-  } 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
-  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/269a2be/packages/renderer-worker/src/parts/DiffDom/DiffDom.js

@@ -1,23 +0,0 @@
-const diffProps = (oldProps, newProps) => {}
-
-const diffNodes = (oldNodes, newNodes) => {}
-
-export const diffDom = (oldDom, newDom) => {
-  const oldChildCount = oldDom.children.length
-  const newChildCount = newDom.children.length
-  if (oldChildCount < newChildCount) {
-    // add some nodes
-  } else if (oldChildCount === newChildCount) {
-    // diff the nodes
-  } else {
-    // remove some nodes
-    return [
-      {
-        method: 'remove',
-        params: {
-          count: oldChildCount - newChildCount,
-        },
-      },
-    ]
-  }
-}

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

@@ -1,127 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as EditorSelection from '../EditorSelection/EditorSelection.js'
-import * as MeasureTextWidth from '../MeasureTextWidth/MeasureTextWidth.js'
-
-const getSelectionFromChange = (change) => {
-  const { start, inserted, end } = change
-  const startRowIndex = start.rowIndex
-  const startColumnIndex = start.columnIndex
-  const insertedLength = inserted.length
-  if (insertedLength === 1) {
-    const newPosition = {
-      rowIndex: startRowIndex + insertedLength - 1,
-      columnIndex: inserted.at(-1).length + startColumnIndex,
-    }
-    return {
-      start: newPosition,
-      end: newPosition,
-    }
-  }
-  const newPosition = {
-    rowIndex: startRowIndex + insertedLength - 1,
-    columnIndex: inserted.at(-1).length,
-  }
-  return {
-    start: newPosition,
-    end: newPosition,
-  }
-}
-
-export const setSelections = (editor, selections) => {
-  Assert.object(editor)
-  Assert.uint32array(selections)
-  return {
-    ...editor,
-    selections,
-  }
-  // editor.selections = selections
-  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
-}
-
-// TODO maybe only accept sorted selection edits in the first place
-
-// TODO avoid allocating too many objects when creating new selection from changes
-export const applyEdit = (editor, changes) => {
-  Assert.object(editor)
-  Assert.array(changes)
-  const newSelections = EditorSelection.from(changes, getSelectionFromChange)
-  // setSelections(editor, newSelections)
-  return newSelections
-}
-
-// TODO visible selections could also be uint16array
-// [top1, left1, width1, height1, top2, left2, width2, height2...]
-
-const isInRange = (rowIndex, min, max) => {
-  return rowIndex >= min && rowIndex <= max
-}
-
-const getX = (line, column, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth) => {
-  if (column === 0) {
-    return 0
-  }
-  const partialText = line.slice(0, column)
-  return MeasureTextWidth.measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing) - halfCursorWidth
-}
-
-const getY = (row, minLineY, rowHeight) => {
-  return (row - minLineY) * rowHeight
-}
-
-export const getVisible = (editor) => {
-  const visibleCursors = []
-  const visibleSelections = []
-  // // TODO binary search
-
-  const { selections, minLineY, maxLineY, rowHeight, lines, fontSize, fontFamily, fontWeight, letterSpacing, cursorWidth } = editor
-  const halfCursorWidth = cursorWidth / 2
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i]
-    const selectionStartColumn = selections[i + 1]
-    const selectionEndRow = selections[i + 2]
-    const selectionEndColumn = selections[i + 3]
-    if (isInRange(selectionEndRow, minLineY, maxLineY)) {
-      const endLine = lines[selectionEndRow]
-      const endLineEndX = getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth)
-      const endLineY = getY(selectionEndRow, minLineY, rowHeight)
-      if (EditorSelection.isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
-        visibleCursors.push(endLineEndX, endLineY)
-        continue
-      }
-      const startLineY = getY(selectionStartRow, minLineY, rowHeight)
-      if (selectionStartRow === selectionEndRow) {
-        const startX = getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth)
-        visibleCursors.push(endLineEndX, endLineY)
-        const width = endLineEndX - startX
-        visibleSelections.push(startX, startLineY, width, rowHeight)
-      } else {
-        if (selectionStartRow >= minLineY) {
-          const startLine = lines[selectionStartRow]
-          const startLineStartX = getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth)
-          const startLineEndX = getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth)
-          const startLineStartY = getY(selectionStartRow, minLineY, rowHeight)
-          const width = startLineEndX - startLineStartX
-          visibleSelections.push(startLineStartX, startLineStartY, width, rowHeight)
-        }
-        const iMin = Math.max(selectionStartRow + 1, minLineY)
-        const iMax = Math.min(selectionEndRow, maxLineY)
-        for (let i = iMin; i < iMax; i++) {
-          const currentLine = lines[i]
-          const currentLineY = getY(i, minLineY, rowHeight)
-          const width = getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, letterSpacing, halfCursorWidth)
-          visibleSelections.push(0, currentLineY, width, rowHeight)
-        }
-        if (selectionEndRow <= maxLineY) {
-          const width = endLineEndX
-          visibleSelections.push(0, endLineY, width, rowHeight)
-          visibleCursors.push(endLineEndX, endLineY)
-        }
-      }
-    }
-  }
-  // TODO maybe use Uint32array or Float64Array?
-  return {
-    cursorInfos: new Float32Array(visibleCursors),
-    selectionInfos: new Float32Array(visibleSelections),
-  }
-}

package/static/269a2be/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleDoubleClick.js

@@ -1,11 +0,0 @@
-import * as EditorSelectWord from './EditorCommandSelectWord.js'
-import * as EditorPosition from './EditorCommandPosition.js'
-
-export const handleDoubleClick = (editor, x, y, offset) => {
-  const position = EditorPosition.at(editor, x, y, offset)
-  return EditorSelectWord.selectWord(
-    editor,
-    position.rowIndex,
-    position.columnIndex
-  )
-}

package/static/269a2be/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleMouseMoveWithAltKey.js

@@ -1,92 +0,0 @@
-import * as EditorPosition from './EditorCommandPosition.js'
-import * as Assert from '../Assert/Assert.js'
-import * as ExtensionHostDefinition from '../ExtensionHost/ExtensionHostDefinition.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-const getTokenIndex = (tokens, offset) => {
-  let currentOffset = 0
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    currentOffset += token.length
-    if (currentOffset >= offset) {
-      return i
-    }
-  }
-  return -1
-}
-
-export const handleMouseMoveWithAltKey = async (editor, x, y, offset) => {
-  Assert.object(editor)
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(offset)
-  const position = EditorPosition.at(editor, x, y, offset)
-  const documentOffset = TextDocument.offsetAt(
-    editor,
-    position.rowIndex,
-    position.columnIndex
-  )
-  try {
-    const definition = await ExtensionHostDefinition.executeDefinitionProvider(
-      editor,
-      documentOffset
-    )
-    if (!definition) {
-      return editor
-    }
-
-    // TODO make sure that editor is not disposed
-
-    const definitionStartPosition = TextDocument.positionAt(
-      editor,
-      definition.startOffset
-    )
-    const definitionEndPosition = TextDocument.positionAt(
-      editor,
-      definition.endOffset
-    )
-    const definitionRelativeStartX = definitionStartPosition.columnIndex
-    const definitionRelativeEndX = definitionEndPosition.columnIndex
-    const definitionRelativeY =
-      definitionStartPosition.rowIndex - editor.minLineY
-
-    const lineTokenMap = editor.lineCache[definitionStartPosition.rowIndex + 1]
-    console.log({ tokenMap: lineTokenMap })
-    console.log({
-      lineCache: editor.lineCache,
-      rowIndex: definitionStartPosition.rowIndex,
-    })
-    if (!lineTokenMap) {
-      return editor
-    }
-    const tokenIndex = getTokenIndex(
-      lineTokenMap.tokens,
-      definitionStartPosition.columnIndex
-    )
-    if (tokenIndex === -1) {
-      return editor
-    }
-    console.log({ token: tokenIndex })
-    // .tokens
-    await RendererProcess.invoke(
-      /* Viewlet.invoke */ 'Viewlet.send',
-      /* id */ 'EditorText',
-      /* method */ 'highlightAsLink',
-      /* relativeY */ definitionRelativeY,
-      /* tokenIndex */ tokenIndex
-    )
-    console.log({ definition })
-    return editor
-  } catch (error) {
-    if (
-      error &&
-      error.message.startsWith(
-        'Failed to execute definition provider: No definition provider found'
-      )
-    ) {
-      return editor
-    }
-    throw error
-  }
-}

package/static/269a2be/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleSingleClick.js

@@ -1,85 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Editor from '../Editor/Editor.js'
-import * as ModifierKey from '../ModifierKey/ModifierKey.js'
-import * as EditorGoToDefinition from './EditorCommandGoToDefinition.js'
-import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
-import * as EditorPosition from './EditorCommandPosition.js'
-
-const handleSingleClickWithAlt = async (editor, position) => {
-  // TODO rectangular selection with alt click,
-  // but also go to definition with alt click
-  const newEditor = await EditorGoToDefinition.goToDefinition(
-    editor,
-    position,
-    /* explicit */ false
-  )
-  return newEditor
-}
-
-const handleSingleClickWithCtrl = async (editor, position) => {
-  const selections = editor.selections
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i]
-    const selectionStartColumn = selections[i + 1]
-    const selectionEndRow = selections[i + 2]
-    const selectionEndColumn = selections[i + 3]
-    if (
-      selectionStartRow === position.rowIndex &&
-      selectionStartColumn === position.columnIndex &&
-      selectionEndRow === position.rowIndex &&
-      selectionEndColumn === position.columnIndex
-    ) {
-      // selection exists -> remove
-      const newSelections = new Uint32Array(selections.length - 4)
-      newSelections.set(selections.subarray(0, i), 0)
-      newSelections.set(selections.subarray(i + 4), i)
-      return Editor.scheduleSelections(editor, newSelections)
-    }
-  }
-  // TODO selection does not exist -> add
-  // TODO insert in order
-  const newSelections = new Uint32Array(selections.length + 4)
-  newSelections.set(selections, 0)
-  const insertIndex = selections.length
-  newSelections[insertIndex] = position.rowIndex
-  newSelections[insertIndex + 1] = position.columnIndex
-  newSelections[insertIndex + 2] = position.rowIndex
-  newSelections[insertIndex + 3] = position.columnIndex
-  return Editor.scheduleSelections(editor, newSelections)
-}
-
-const handleSingleClickDefault = (editor, position) => {
-  EditorMoveSelection.state.position = position
-  return {
-    ...editor,
-    selections: new Uint32Array([
-      position.rowIndex,
-      position.columnIndex,
-      position.rowIndex,
-      position.columnIndex,
-    ]),
-    focused: true,
-  }
-}
-
-const getFn = (modifier) => {
-  switch (modifier) {
-    case ModifierKey.Alt:
-      return handleSingleClickWithAlt
-    case ModifierKey.Ctrl:
-      return handleSingleClickWithCtrl
-    default:
-      return handleSingleClickDefault
-  }
-}
-
-export const handleSingleClick = (editor, modifier, x, y, offset) => {
-  Assert.object(editor)
-  Assert.string(modifier)
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(offset)
-  const position = EditorPosition.at(editor, x, y, offset)
-  const fn = getFn(modifier)
-  return fn(editor, position)
-}

package/static/269a2be/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTripleClick.js

@@ -1,11 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as EditorSelectLine from './EditorCommandSelectLine.js'
-
-// TODO rowIndex and columnIndex should already be set because of singleClick which occurred before triple click
-export const handleTripleClick = (editor, x, y, offset) => {
-  Assert.object(editor)
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(offset)
-  return EditorSelectLine.selectLine(editor)
-}