@lvce-editor/server 0.0.26 → 0.0.29

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSnippet.js

@@ -1,45 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-// const getIndent =
-// TODO rename to insertSnippet
-// TODO handle snippet tabstops and cursors $0 -> becomes cursor
-export const editorSnippet = (editor, snippet) => {
-  // TODO verify that deleted fits in the line
-  const insertedLines = snippet.inserted.split('\n')
-  const changes = []
-  for (const selection of editor.selections) {
-    if (insertedLines.length > 1) {
-      const line = TextDocument.getLine(editor, selection.start.rowIndex)
-      const indent = TextDocument.getIndent(line)
-      const insertedLinesHere = [
-        insertedLines[0],
-        ...insertedLines.slice(1).map((line) => indent + line),
-      ]
-      console.log({ insertedLinesHere })
-      changes.push({
-        start: {
-          rowIndex: selection.start.rowIndex,
-          columnIndex: selection.start.columnIndex - snippet.deleted,
-        },
-        end: selection.end,
-        inserted: insertedLinesHere,
-        deleted: [''],
-        origin: 'editorSnippet',
-      })
-    } else {
-      changes.push({
-        start: {
-          rowIndex: selection.start.rowIndex,
-          columnIndex: selection.start.columnIndex - snippet.deleted,
-        },
-        end: selection.end,
-        inserted: insertedLines,
-        deleted: [''],
-        origin: 'editorSnippet',
-      })
-    }
-  }
-  console.log(JSON.stringify(changes, null, 2))
-  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandTabCompletion.js

@@ -1,23 +0,0 @@
-import * as ExtensionHostTabCompletion from '../ExtensionHost/ExtensionHostTabCompletion.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as EditorSnippet from './EditorCommandSnippet.js'
-
-const getTabCompletion = async (editor) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  const tabCompletion =
-    await ExtensionHostTabCompletion.executeTabCompletionProvider(
-      editor,
-      offset
-    )
-  return tabCompletion
-}
-
-export const editorTabCompletion = async (editor) => {
-  // TODO race condition
-  // TODO get tab completion for each cursor
-  const tabCompletion = await getTabCompletion(editor)
-  if (!tabCompletion) {
-    return editor
-  }
-  return EditorSnippet.editorSnippet(editor, tabCompletion)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandToggleBlockComment.js

@@ -1,226 +0,0 @@
-import * as Languages from '../Languages/Languages.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as Editor from '../Editor/Editor.js'
-
-const RE_WHITESPACE_AT_START = /^\s+/
-const RE_WHITESPACE_AT_END = /\s+$/
-
-// const blockComment = ['<!--', '-->']
-
-const getBlockComment = async (editor) => {
-  const languageConfiguration = await Languages.getLanguageConfiguration(editor)
-  console.log({ languageConfiguration })
-  if (
-    !languageConfiguration ||
-    !languageConfiguration.comments ||
-    !languageConfiguration.comments.blockComment
-  ) {
-    return undefined
-  }
-  return languageConfiguration.comments.blockComment
-}
-
-export const editorToggleBlockComment = async (editor) => {
-  if (!Languages.hasLoaded()) {
-    console.log('languages have not yet loaded')
-    await Languages.waitForLoad()
-  }
-  editor.languageId = Languages.getLanguageId(editor.uri) // TODO avoid side effect here
-  console.log('languages have loaded')
-  console.log({ editor: { ...editor } })
-  const blockComment = await getBlockComment(editor)
-  if (!blockComment) {
-    return editor
-  }
-  const rowIndex = editor.cursor.rowIndex
-  const columnIndex = editor.cursor.columnIndex
-  const line = TextDocument.getLine(editor, rowIndex)
-  const numberOfLines = editor.lines.length
-  let endRowIndex = rowIndex
-  let endColumnIndex = -1
-  const blockCommentStart = blockComment[0]
-  const blockCommentEnd = blockComment[1]
-  while (endRowIndex < numberOfLines) {
-    const line = TextDocument.getLine(editor, endRowIndex)
-    endColumnIndex = line.indexOf(blockCommentEnd)
-    if (endColumnIndex !== -1) {
-      break
-    }
-    endRowIndex++
-  }
-  let startColumnIndex = -1
-  let startRowIndex = rowIndex
-  while (startRowIndex >= 0) {
-    const line = TextDocument.getLine(editor, startRowIndex)
-    startColumnIndex = line.indexOf(blockCommentStart)
-    if (startColumnIndex !== -1) {
-      break
-    }
-    startRowIndex--
-  }
-  const changes = []
-
-  if (startColumnIndex !== -1 && endColumnIndex !== -1) {
-    if (startRowIndex === endRowIndex) {
-      const change1 = {
-        start: {
-          rowIndex,
-          columnIndex: startColumnIndex,
-        },
-        end: {
-          rowIndex,
-          columnIndex: startColumnIndex + blockCommentStart.length,
-        },
-        inserted: [],
-        deleted: [blockCommentStart],
-        origin: 'toggleBlockComment',
-      }
-      const change2 = {
-        start: {
-          rowIndex,
-          columnIndex: endColumnIndex - blockCommentStart.length,
-        },
-        end: {
-          rowIndex,
-          columnIndex:
-            endColumnIndex - blockCommentStart.length + blockCommentEnd.length,
-        },
-        inserted: [],
-        deleted: [blockCommentEnd],
-        origin: 'toggleBlockComment',
-      }
-      changes.push(change1, change2)
-      // Editor.moveCursors(editor, (editor, cursor) => {
-      //   let newColumnIndex = cursor.columnIndex - blockComment[0].length
-      //   if (cursor.columnIndex === endColumnIndex + blockComment[1].length) {
-      //     newColumnIndex -= blockComment[1].length
-      //   }
-      //   return {
-      //     rowIndex: cursor.rowIndex,
-      //     columnIndex: newColumnIndex,
-      //   }
-      // })
-    } else {
-      const change1 = {
-        start: {
-          rowIndex: startRowIndex,
-          columnIndex: startColumnIndex,
-        },
-        end: {
-          rowIndex: startRowIndex,
-          columnIndex: startColumnIndex + blockCommentStart.length,
-        },
-        inserted: [],
-        deleted: [blockCommentStart],
-        origin: 'toggleBlockComment',
-      }
-      const change2 = {
-        start: {
-          rowIndex: endRowIndex,
-          columnIndex: endColumnIndex,
-        },
-        end: {
-          rowIndex: endRowIndex,
-          columnIndex: endColumnIndex + blockCommentEnd.length,
-        },
-        inserted: [],
-        deleted: [blockCommentEnd],
-        origin: 'toggleBlockComment',
-      }
-      changes.push(change1, change2)
-
-      // const oldRow1 = TextDocument.getLine(editor, startRowIndex)
-      // const newRow1 =
-      //   oldRow1.slice(0, startColumnIndex) +
-      //   oldRow1.slice(startColumnIndex + blockCommentStart.length)
-      // const oldRow2 = TextDocument.getLine(editor, endRowIndex)
-      // const newRow2 =
-      //   oldRow2.slice(0, endColumnIndex) +
-      //   oldRow2.slice(endColumnIndex + blockCommentEnd.length)
-      // // TODO use applyEdit to have undo functionality
-      // TextDocument.setLine(editor, startRowIndex, newRow1)
-      // TextDocument.setLine(editor, endRowIndex, newRow2)
-    }
-    // TODO move cursors
-  } else {
-    const whitespaceAtStart = line.match(RE_WHITESPACE_AT_START)
-    const whitespaceAtEnd = line.match(RE_WHITESPACE_AT_END)
-    let startColumnIndex = 0
-    let endColumnIndex = line.length
-    if (whitespaceAtStart) {
-      startColumnIndex += whitespaceAtStart[0].length
-    }
-    if (whitespaceAtEnd) {
-      endColumnIndex -= whitespaceAtEnd[0].length
-    }
-    const change1 = {
-      start: {
-        rowIndex,
-        columnIndex: startColumnIndex,
-      },
-      end: {
-        rowIndex,
-        columnIndex: startColumnIndex,
-      },
-      inserted: [blockCommentStart],
-      deleted: [],
-      origin: 'toggleBlockComment',
-    }
-    const change2 = {
-      start: {
-        rowIndex,
-        columnIndex: endColumnIndex + blockCommentStart.length,
-      },
-      end: {
-        rowIndex,
-        columnIndex: endColumnIndex + blockCommentStart.length,
-      },
-      inserted: [blockCommentEnd],
-      deleted: [],
-      origin: 'toggleBlockComment',
-    }
-    changes.push(change1, change2)
-    // TextDocument.setLine(
-    //   editor,
-    //   rowIndex,
-    //   line.slice(0, startColumnIndex) +
-    //     blockComment[0] +
-    //     line.slice(startColumnIndex, endColumnIndex) +
-    //     blockComment[1] +
-    //     line.slice(endColumnIndex)
-    // )
-    // Editor.moveCursors(editor, (editor, cursor) => {
-    //   let newColumnIndex = cursor.columnIndex + blockComment[0].length
-    //   if (cursor.columnIndex === endColumnIndex) {
-    //     newColumnIndex += blockComment[1].length
-    //   }
-    //   return {
-    //     rowIndex: cursor.rowIndex,
-    //     columnIndex: newColumnIndex,
-    //   }
-    // })
-  }
-  // if (line.startsWith(blockComment[0]) && line.endsWith(blockComment[1])) {
-  //   lines[rowIndex] = line.slice(
-  //     blockComment[0].length,
-  //     line.length - blockComment[1].length
-  //   )
-  //   Editor.moveCursors((editor, cursor) => {
-  //     return {
-  //       rowIndex: cursor.rowIndex,
-  //       columnIndex: cursor.columnIndex - blockComment[0].length,
-  //     }
-  //   })
-  // } else {
-  //   lines[rowIndex] = blockComment[0] + line + blockComment[1]
-  //   Editor.moveCursors((editor, cursor) => {
-  //     return {
-  //       rowIndex: cursor.rowIndex,
-  //       columnIndex: cursor.columnIndex + blockComment[0].length,
-  //     }
-  //   })
-  // }
-  // RendererProcess.send([/* setLines */ 2135, /* lines */ lines])
-
-  return Editor.scheduleDocument(editor, changes)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandType.js

@@ -1,110 +0,0 @@
-// import * as EditorCompletion from '../EditorCompletion/EditorCompletion.js'
-import * as Editor from '../Editor/Editor.js'
-import { editorReplaceSelections } from './EditorCommandReplaceSelection.js'
-import * as EditorCommandCompletion from './EditorCommandCompletion.js'
-import * as ExtensionHostBraceCompletion from '../ExtensionHost/ExtensionHostBraceCompletion.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as Languages from '../Languages/Languages.js'
-import * as ExtensionHostClosingTag from '../ExtensionHost/ExtensionHostClosingTagCompletion.js'
-
-const RE_CHARACTER = new RegExp(/^\p{L}/, 'u')
-
-export const state = {
-  listeners: [],
-}
-
-const getMatchingClosingBrace = (brace) => {
-  switch (brace) {
-    case '{':
-      return '}'
-    case '(':
-      return ')'
-    case '[':
-      return ']'
-    default:
-      return '???'
-  }
-}
-
-const isBrace = (text) => {
-  if (text.length !== 1) {
-    return false
-  }
-  switch (text) {
-    case '{':
-    case '(':
-    case '[':
-      return true
-    default:
-      return false
-  }
-}
-
-const isSlash = (text) => {
-  return text === '/'
-}
-
-const editorTypeWithBraceCompletion = async (editor, text) => {
-  if (!Languages.state.loaded) {
-    await Languages.waitForLoad()
-  }
-  editor.languageId = Languages.getLanguageId(editor.uri) // TODO avoid side effect here
-
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  const result =
-    await ExtensionHostBraceCompletion.executeBraceCompletionProvider(
-      editor,
-      offset,
-      text
-    )
-  if (result) {
-    const closingBrace = getMatchingClosingBrace(text)
-    const insertText = text + closingBrace
-    const changes = editorReplaceSelections(editor, [insertText], 'editorType')
-    return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-  }
-  const changes = editorReplaceSelections(editor, [text], 'editorType')
-  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-}
-
-const editorTypeWithSlashCompletion = async (editor, text) => {
-  if (!Languages.state.loaded) {
-    await Languages.waitForLoad()
-  }
-  editor.languageId = Languages.getLanguageId(editor.uri) // TODO avoid side effect here
-
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  const result = await ExtensionHostClosingTag.executeClosingTagProvider(
-    editor,
-    offset,
-    text
-  )
-  const changes = editorReplaceSelections(editor, [text], 'editorType')
-  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-}
-
-export const editorType = async (editor, text) => {
-  if (isBrace(text)) {
-    return editorTypeWithBraceCompletion(editor, text)
-  }
-  if (isSlash(text)) {
-    return editorTypeWithSlashCompletion(editor, text)
-  }
-  const changes = editorReplaceSelections(editor, [text], 'editorType')
-  // // TODO trigger characters should be monomorph -> then skip this check
-  // if (
-  //   editor.completionTriggerCharacters &&
-  //   editor.completionTriggerCharacters.includes(text)
-  // ) {
-  //   Command.execute(/* EditorCompletion.openFromType */ 988)
-  // }
-
-  // TODO should editor type command know about editor completion? -> no
-  EditorCommandCompletion.openFromType(editor, text)
-  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-}
-
-export const onDidType = (listener) => {
-  state.listeners.push(listener)
-  // TODO unregister
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorDiagnostics/EditorDiagnostics.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorDiagnostics from './EditorDiagnostics.js'
-
-export const __initialize__ = () => {
-  Command.register('EditorDiagnostics.hydrate', EditorDiagnostics.hydrate)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorError/EditorError.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorError from './EditorError.js'
-
-export const __initialize__ = () => {
-  Command.register(3900, EditorError.show)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorError/EditorError.js

@@ -1,13 +0,0 @@
-import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const show = async (editor, message, position) => {
-  const x = EditorPosition.x(editor, position)
-  const y = EditorPosition.y(editor, position)
-  await RendererProcess.invoke(
-    /* EditorError.show */ 'EditorError.show',
-    /* message */ message,
-    /* x */ x,
-    /* y */ y
-  )
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorRename/EditorRename.ipc.js

@@ -1,8 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorRename from './EditorRename.js'
-
-export const __initialize__ = () => {
-  Command.register('EditorRename.open', EditorRename.open)
-  Command.register('EditorRename.finish', EditorRename.finish)
-  Command.register('EditorRename.abort', EditorRename.abort)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorRename/EditorRename.js

@@ -1,94 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Editor from '../Editor/Editor.js'
-import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
-import * as ExtensionHostRename from '../ExtensionHost/ExtensionHostRename.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-export const state = {
-  editor: undefined,
-}
-
-const prepareRename = async (editor) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  return ExtensionHostRename.executePrepareRenameProvider(editor, offset)
-}
-
-const rename = (editor, newName) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  return ExtensionHostRename.executeRenameProvider(editor, offset)
-}
-
-export const open = async (editor) => {
-  // TODO handle error and add tests for handled error
-  const prepareRenameResult = await prepareRename(editor)
-
-  // TODO race condition, what is when editor is closed before promise resolves
-
-  if (prepareRenameResult.canRename) {
-    const x = EditorPosition.x(editor, editor.cursor)
-    const y = EditorPosition.y(editor, editor.cursor)
-    // const prepareRenameResult = await prepareRename(editor)
-    // console.log({ prepareRenameResult })
-    await RendererProcess.invoke(
-      /* EditorRename.openWidget */ 4512,
-      /* x */ x,
-      /* y */ y
-    )
-  } else {
-    // TODO also show error when promise rejects
-    await Command.execute(
-      /* EditorError.show */ 3900,
-      /* editor */ editor,
-      /* message */ 'You cannot rename this element',
-      /* position */ editor.cursor
-    )
-  }
-}
-
-const toPositionBasedEdits = (textDocument, edits) => {
-  const positionBasedEdits = []
-  for (const edit of edits) {
-    const start = TextDocument.positionAt(textDocument, edit.offset)
-    const end = TextDocument.positionAt(
-      textDocument,
-      edit.offset + edit.inserted.length - edit.deleted
-    )
-    positionBasedEdits.push({
-      start,
-      end,
-      inserted: edit.inserted.split('\n'),
-      deleted: [''],
-    })
-    console.log(edit)
-  }
-  return positionBasedEdits
-}
-
-// TODO how to best apply workspace edit?
-const applyWorkspaceEdits = async (editor, workspaceEdits) => {
-  if (workspaceEdits.length === 0) {
-    return
-  }
-  const workspaceEdit = workspaceEdits[0]
-  const positionBasedEdits = toPositionBasedEdits(
-    editor.textDocument,
-    workspaceEdit.edits
-  )
-  Editor.scheduleDocumentAndCursorsSelections(editor, positionBasedEdits)
-}
-
-export const finish = async (editor) => {
-  const newName = await RendererProcess.invoke(/* EditorRename.finish */ 4513)
-  console.log('do actual rename', { value: newName })
-  // TODO support canceling rename (e.g. when user presses escape)
-  const workspaceEdits = await rename(editor, newName)
-  await applyWorkspaceEdits(editor, workspaceEdits)
-  // console.log({ workspaceEdits })
-  // Editor.scheduleDocumentAndSelections(editor)
-  // console.log({ workspaceEdits })
-}
-
-export const abort = async () => {
-  await RendererProcess.invoke(/* EditorRename.closeWidget */ 4514)
-}

package/static/0895dce/packages/renderer-worker/src/parts/Env/Env.js

@@ -1 +0,0 @@
-export const isWorker = typeof WorkerGlobalScope !== 'undefined'

package/static/0895dce/packages/renderer-worker/src/parts/ErrorHandling/ErrorHandling.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ErrorHandling from './ErrorHandling.js'
-
-export const __initialize__ = () => {
-  Command.register('ErrorHandling.handleError', ErrorHandling.handleError)
-}

package/static/0895dce/packages/renderer-worker/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,91 +0,0 @@
-import * as Command from '../Command/Command.js'
-
-// TODO use https://github.com/stack-tools-js/stack-tools to print error
-
-const enhanceErrorMessage = (error) => {
-  if (!error) {
-    return {
-      message: `Error: ${error}`,
-      stack: undefined,
-      codeFrame: undefined,
-    }
-  }
-  let message = `${error}`
-  while (error.cause) {
-    error = error.cause
-    message += `: ${error}`
-  }
-  console.log({ error })
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr,
-  }
-}
-
-// const getErrorMessage = (error) => {
-//   let message = ``
-//   if (error && error.message) {
-//     message += error.message
-//   }
-//   if (error && error.stack) {
-//     message += `\n${error.stack}`
-//   }
-//   if (error && error.cause) {
-//     message += getErrorMessage(error.cause)
-//   }
-//   return message
-// }
-
-// const printError = (error) => {
-//   const message = getErrorMessage(error)
-//   console.error(message)
-// }
-
-const printError = (error) => {
-  console.error(error)
-  if (error && error.cause) {
-    console.error('caused by')
-    printError(error.cause)
-  }
-}
-
-// TODO state is not needed here but because jest doesn't support mocking for esm yet this is a workaround
-export const state = {
-  async handleError(error) {
-    printError(error)
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Notification.create */ 'Notification.create',
-      /* type */ 'error',
-      /* text */ enhancedErrorMessage.message
-    )
-  },
-  async showErrorDialog(error) {
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Dialog.showMessage */ 'Dialog.showMessage',
-      /* message */ enhancedErrorMessage
-    )
-  },
-  seenWarnings: [],
-}
-
-export const handleError = async (error) => {
-  await state.handleError(error)
-}
-
-export const showErrorDialog = async (error) => {
-  await state.showErrorDialog(error)
-}
-
-export const warn = (...args) => {
-  const stringified = JSON.stringify(args)
-  if (state.seenWarnings.includes(stringified)) {
-    return
-  }
-  state.seenWarnings.push(stringified)
-  console.warn(...args)
-}

package/static/0895dce/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostBraceCompletion.js

@@ -1,18 +0,0 @@
-import * as ExtensionHost from './ExtensionHostCore.js'
-import * as ExtensionHostManagement from './ExtensionHostManagement.js'
-
-export const executeBraceCompletionProvider = async (
-  textDocument,
-  offset,
-  openingBrace
-) => {
-  await ExtensionHostManagement.activateByEvent(
-    `onBraceCompletion:${textDocument.languageId}`
-  )
-  return ExtensionHost.invoke(
-    /* ExtensionHostBraceCompletion.executeBraceCompletionProvider */ 'ExtensionHostBraceCompletion.executeBraceCompletionProvider',
-    /* textDocumentId */ textDocument.id,
-    /* offset */ offset,
-    /* openingBrace */ openingBrace
-  )
-}

package/static/0895dce/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostClosingTagCompletion.js

@@ -1,18 +0,0 @@
-import * as ExtensionHost from './ExtensionHostCore.js'
-import * as ExtensionHostManagement from './ExtensionHostManagement.js'
-
-export const executeClosingTagProvider = async (
-  textDocument,
-  offset,
-  openingBrace
-) => {
-  await ExtensionHostManagement.activateByEvent(
-    `onClosingTag:${textDocument.languageId}`
-  )
-  return ExtensionHost.invoke(
-    /* ExtensionHostClosingTag.executeClosingTagProvider */ 'ExtensionHostClosingTag.executeClosingTagProvider',
-    /* textDocumentId */ textDocument.id,
-    /* offset */ offset,
-    /* openingBrace */ openingBrace
-  )
-}