@lvce-editor/server 0.0.26 → 0.0.29

package/static/0895dce/packages/renderer-process/src/parts/Editor/LayerCursor.js

@@ -1,129 +0,0 @@
-import * as Platform from '../Platform/Platform.js'
-
-const create$Cursor = () => {
-  const $Cursor = document.createElement('div')
-  $Cursor.className = 'EditorCursor'
-  return $Cursor
-}
-
-const render$Cursor = ($Cursor, $Texts, cursor) => {
-  $Cursor.style.top = `${cursor.top}px`
-  const range = document.createRange()
-  if (cursor.leftIndex === -1) {
-    console.warn('cursor left is negative')
-    $Cursor.style.left = `0px` // TODO need to compute column width, this would only work for monospace fonts
-    return
-  }
-  const $Row = $Texts.children[cursor.topIndex]
-  if (!$Row) {
-    console.warn('no row', cursor, $Row)
-    return
-  }
-  const $Node = $Row.children[cursor.leftIndex]
-  if (!$Node) {
-    console.warn('no node', cursor, $Row)
-    return
-  }
-  if (cursor.leftIndex === 0 && cursor.remainingOffset === 0) {
-    $Cursor.style.left = `0px`
-  } else {
-    const $TextNode = $Node.firstChild
-    range.setStart($TextNode, cursor.remainingOffset)
-    range.setEnd($TextNode, cursor.remainingOffset)
-    const rect = range.getBoundingClientRect()
-    const left = Math.round(rect.left)
-    $Cursor.style.left = `${left}px`
-  }
-}
-
-const render$CursorsLess = ($Cursors, $Texts, cursors) => {
-  for (let i = 0; i < $Cursors.children.length; i++) {
-    render$Cursor($Cursors.children[i], cursors[i])
-  }
-  const fragment = document.createDocumentFragment()
-  for (let i = $Cursors.children.length; i < cursors.length; i++) {
-    const $Cursor = create$Cursor()
-    render$Cursor($Cursor, $Texts, cursors[i])
-    fragment.append($Cursor)
-  }
-  $Cursors.append(fragment)
-}
-
-const render$CursorsEqual = ($Cursors, $Texts, cursors) => {
-  for (let i = 0; i < cursors.length; i++) {
-    render$Cursor($Cursors.children[i], $Texts, cursors[i])
-  }
-}
-
-const render$CursorsMore = ($Cursors, $Texts, cursors) => {
-  for (let i = 0; i < cursors.length; i++) {
-    render$Cursor($Cursors.children[i], $Texts, cursors[i])
-  }
-  const diff = $Cursors.children.length - cursors.length
-  for (let i = 0; i < diff; i++) {
-    $Cursors.lastChild.remove()
-  }
-}
-
-const render$Cursors = ($Cursors, $Texts, cursors) => {
-  if ($Cursors.children.length < cursors.length) {
-    render$CursorsLess($Cursors, $Texts, cursors)
-  } else if ($Cursors.children.length === cursors.length) {
-    render$CursorsEqual($Cursors, $Texts, cursors)
-  } else {
-    render$CursorsMore($Cursors, $Texts, cursors)
-  }
-}
-
-const renderCursorsNative = (state, cursors) => {
-  if (cursors.length > 1) {
-    console.warn('[editor] cannot render more than one native cursor')
-    return
-  }
-  if (cursors.length === 0) {
-    return
-  }
-  const cursor = cursors[0]
-  const $Rows = state.$LayerText
-  const $StartRow = $Rows.children[cursor.rowIndex]
-  let startOffset = 0
-  let $Anchor
-  for (let i = 0; i < $StartRow.children.length; i++) {
-    if (startOffset >= cursor.columnIndex) {
-      console.log({ startOffset })
-      $Anchor = $StartRow.children[i - 1].firstChild
-      startOffset -= $Anchor.textContent.length
-      startOffset = cursor.columnIndex - startOffset
-      break
-    }
-    startOffset += $StartRow.children[i].textContent.length
-  }
-  if (!$Anchor) {
-    $Anchor = $StartRow.children[$StartRow.children.length - 1].firstChild
-    startOffset -= $Anchor.textContent.length
-    startOffset = cursor.columnIndex - startOffset
-  }
-  const selection = document.getSelection()
-  if (
-    selection.anchorNode === $Anchor &&
-    selection.focusNode === $Anchor &&
-    selection.anchorOffset === startOffset &&
-    selection.focusOffset === startOffset
-  ) {
-    return
-  }
-  state.shouldIgnoreSelectionChange = true
-  const documentRange = document.createRange()
-  documentRange.setStart($Anchor, startOffset)
-  documentRange.setEnd($Anchor, startOffset)
-  selection.removeAllRanges()
-  selection.addRange(documentRange)
-}
-
-export const setCursors = (state, cursors) => {
-  if (Platform.isMobileOrTablet()) {
-    renderCursorsNative(state, cursors)
-    return
-  }
-  render$Cursors(state.$LayerCursor, state.$LayerText, cursors)
-}

package/static/0895dce/packages/renderer-process/src/parts/Editor/LayerSelections.js

@@ -1,70 +0,0 @@
-import * as Platform from '../Platform/Platform.js'
-
-const create$Selection = () => {
-  const $Selection = document.createElement('div')
-  $Selection.className = 'EditorSelection'
-  return $Selection
-}
-
-const render$Selection = ($Selection, selection) => {
-  // TODO have many decorations per row
-  // no absolute positioning
-  $Selection.style.top = `${selection.top}px`
-  $Selection.style.left = `${selection.left}px`
-  $Selection.style.width = `${selection.width}px`
-  $Selection.style.height = `${selection.height}px`
-}
-
-const render$SelectionsLess = ($Selections, selections) => {
-  for (let i = 0; i < $Selections.children.length; i++) {
-    render$Selection($Selections.children[i], selections[i])
-  }
-  const fragment = document.createDocumentFragment()
-  for (let i = $Selections.children.length; i < selections.length; i++) {
-    const $Selection = create$Selection()
-    render$Selection($Selection, selections[i])
-    fragment.append($Selection)
-  }
-  $Selections.append(fragment)
-}
-
-const render$SelectionsEqual = ($Selections, selections) => {
-  for (let i = 0; i < selections.length; i++) {
-    render$Selection($Selections.children[i], selections[i])
-  }
-}
-
-const render$SelectionsMore = ($Selections, selections) => {
-  for (let i = 0; i < selections.length; i++) {
-    render$Selection($Selections.children[i], selections[i])
-  }
-  const diff = $Selections.children.length - selections.length
-  for (let i = 0; i < diff; i++) {
-    $Selections.lastChild.remove()
-  }
-}
-
-const render$Selections = ($Selections, selections) => {
-  if ($Selections.children.length < selections.length) {
-    render$SelectionsLess($Selections, selections)
-  } else if ($Selections.children.length === selections.length) {
-    render$SelectionsEqual($Selections, selections)
-  } else {
-    render$SelectionsMore($Selections, selections)
-  }
-}
-
-const renderSelectionsNative = (state, selections) => {
-  if (selections.length > 1) {
-    console.warn('[editor] cannot render more than one native selection')
-
-  }
-}
-
-export const setSelections = (state, selections) => {
-  if (Platform.isMobileOrTablet()) {
-    renderSelectionsNative(state, selections)
-    return
-  }
-  render$Selections(state.$LayerSelections, selections)
-}

package/static/0895dce/packages/renderer-process/src/parts/EditorController/EditorController.js

@@ -1,18 +0,0 @@
-import * as EditorHelper from '../Editor/EditorHelper.js'
-import * as Editor from '../Editor/Editor.js'
-import * as ActiveViewlet from '../Viewlet/ActiveViewlet.js'
-
-export const wrapEditorCommand = (fn) => {
-  const wrappedCommand = (id, ...args) => {
-    const state = ActiveViewlet.getState('EditorText')
-    console.assert(state)
-    fn(state, ...args)
-  }
-  return wrappedCommand
-}
-
-export const create = (id) => {
-  const editor = Editor.create()
-  EditorHelper.setState(id, editor)
-  return editor.$Editor
-}

package/static/0895dce/packages/renderer-process/src/parts/EditorGroup/EditorGroup.js

@@ -1,55 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as EditorHelper from '../Editor/EditorHelper.js'
-import * as EditorTabs from '../EditorTab/EditorTab.js'
-import * as Layout from '../Layout/Layout.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-
-const handleEditorTabsContextMenu = (event) => {
-  event.preventDefault()
-  const x = event.clientX
-  const y = event.clientY
-  RendererWorker.send([
-    /* editorTabsHandleContextMenu */ 'Main.handleTabContextMenu',
-    /* x */ x,
-    /* y */ y,
-  ])
-}
-
-export const create = () => {
-  const $EditorTabs = EditorTabs.create()
-
-  const $Editors = document.createElement('div')
-  $Editors.className = 'Editors'
-
-  // TODO create should not have side effect of mounting
-  // TODO this causes 2 times layout (when also calling add after)
-  Layout.state.$Main.append($EditorTabs, $Editors)
-  return {
-    $EditorTabs,
-    $Editors,
-  }
-}
-
-export const addOne = (state, id, uri, languageId) => {
-  EditorTabs.addOne(state.$EditorTabs, id, uri, languageId)
-  // const $Editor = EditorController.create(id)
-  // const $EditorTab = EditorTabsController.create(id, uri, languageId)
-  // TODO should call addOne as well
-  const editorState = Editor.create()
-  EditorHelper.setState(id, editorState)
-  Editor.mount(editorState, state.$Editors)
-  return editorState
-}
-
-export const replaceOne = (state, id, uri, languageId) => {
-  console.log('replace one')
-  EditorTabs.addOne(state.$EditorTabs, id, uri, languageId)
-}
-
-// TODO remove single tab
-export const removeOne = (state, index) => {
-  // EditorTabs.removeOne(state.$EditorTabs, index)
-  // Editor.removeOne(state.$Editors, index)
-  state.$Editors.remove()
-  state.$EditorTabs.remove()
-}

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

@@ -1,39 +0,0 @@
-import * as Widget from '../Widget/Widget.js'
-import * as InputBox from '../InputBox/InputBox.js'
-import * as Focus from '../Focus/Focus.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-
-const handleBlur = () => {
-  RendererWorker.send([/* EditorRename.abort */ 'EditorRename.abort'])
-}
-
-export const create = (x, y) => {
-  const $RenameWidgetInputBox = InputBox.create()
-  $RenameWidgetInputBox.className = 'RenameWidgetInputBox'
-  $RenameWidgetInputBox.onblur = handleBlur
-  const $RenameWidget = document.createElement('div')
-  $RenameWidget.className = 'RenameWidget'
-  $RenameWidget.append($RenameWidgetInputBox)
-  $RenameWidget.style.left = `${x}px`
-  $RenameWidget.style.top = `${y}px`
-  Widget.append($RenameWidget)
-  Focus.focus($RenameWidgetInputBox, 'editorRename')
-  return {
-    $RenameWidget,
-    $RenameWidgetInputBox,
-  }
-}
-
-export const dispose = (state) => {
-  // TODO focus editor
-  Widget.remove(state.$RenameWidget)
-}
-
-// TODO could also be event based
-// finish -> finish -> finishWithValue
-
-export const finish = (state) => {
-  const value = state.$RenameWidgetInputBox.value
-  // TODO don't like side effect here
-  return value
-}

package/static/0895dce/packages/renderer-process/src/parts/EditorTab/EditorTab.js

@@ -1,128 +0,0 @@
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-
-// TODO windows
-const getFileName = (uri) => {
-  return uri.slice(uri.lastIndexOf('/') + 1)
-}
-
-const handleEditorTabsContextMenu = (event) => {
-  event.preventDefault()
-  const x = event.clientX
-  const y = event.clientY
-  RendererWorker.send([
-    /* editorTabsHandleContextMenu */ 'Main.handleTabContextMenu',
-    /* x */ x,
-    /* y */ y,
-  ])
-}
-
-/**
- * @param {MouseEvent} event
- */
-const handleMouseDown = (event) => {
-  event.preventDefault()
-  const $Target = event.target
-  console.log({ $Target })
-  // TODO if middle click -> close tab
-  // else if tab is not focused -> focus tab
-  // else noop
-  switch (event.button) {
-    case 0:
-      console.log('left click')
-      break
-    case 1:
-      RendererWorker.send([/* Main.closeEditor */ 'Main.closeFocusedEditor'])
-      break
-    default:
-      break
-  }
-}
-
-export const create = () => {
-  const $EditorTabs = document.createElement('ul')
-  $EditorTabs.className = 'EditorTabs'
-  $EditorTabs.oncontextmenu = handleEditorTabsContextMenu
-  $EditorTabs.onmousedown = handleMouseDown
-  return $EditorTabs
-}
-
-const create$Tab = () => {
-  const $Tab = document.createElement('li')
-  $Tab.setAttribute('role', 'tab')
-  $Tab.className = 'EditorTab'
-  $Tab.ariaSelected = 'true'
-  $Tab.tabIndex = 0
-  // Set aria-description to empty string so that screen readers don't read title as well
-  // More details https://github.com/microsoft/vscode/issues/95378
-  $Tab.setAttribute('aria-description', '')
-  const $TabLabel = document.createElement('span')
-  return $Tab
-}
-
-const render$Tab = ($Tab, id, uri, languageId) => {
-  const fileName = getFileName(uri)
-  $Tab.textContent = fileName
-  $Tab.title = uri
-  $Tab.dataset.languageId = languageId
-  $Tab.dataset.fileName = fileName
-}
-
-// const render$TabsLess = ($Tabs, tabs) => {
-//   for (let i = 0; i < $Tabs.children.length; i++) {
-//     render$Tab($Tabs.children[i], tabs[i])
-//   }
-//   const fragment = document.createDocumentFragment()
-//   for (let i = $Tabs.children.length; i < tabs.length; i++) {
-//     const $Tab = create$Tab()
-//     render$Tab($Tab, tabs[i])
-//     fragment.append($Tab)
-//   }
-//   $Tabs.append(fragment)
-// }
-
-// const render$TabsEqual = ($Tabs, tabs) => {
-//   for (let i = 0; i < tabs.length; i++) {
-//     render$Tab($Tabs.children[i], tabs[i])
-//   }
-// }
-
-// const render$TabsMore = ($Tabs, tabs) => {
-//   for (let i = 0; i < tabs.length; i++) {
-//     render$Tab($Tabs.children[i], tabs[i])
-//   }
-//   const diff = $Tabs.children.length - tabs.length
-//   for (let i = 0; i < diff; i++) {
-//     $Tabs.lastChild.remove()
-//   }
-// }
-
-// const render$Tabs = ($Tabs, tabs) => {
-//   if ($Tabs.children.length < tabs.length) {
-//     render$TabsLess($Tabs, tabs)
-//   } else if ($Tabs.children.length === tabs.length) {
-//     render$TabsEqual($Tabs, tabs)
-//   } else {
-//     render$TabsMore($Tabs, tabs)
-//   }
-// }
-
-// export const setTabs = (state, tabs) => {
-//   render$Tabs(state.$EditorTabs, tabs)
-// }
-
-export const addOne = ($EditorTabs, id, uri, languageId) => {
-  const $EditorTab = create$Tab()
-  render$Tab($EditorTab, id, uri, languageId)
-  $EditorTabs.append($EditorTab)
-}
-
-// TODO should pass index as well
-export const replaceOne = ($EditorTabs, id, uri, languageId) => {
-  render$Tab($EditorTabs.firstChild, id, uri, languageId)
-}
-
-export const removeOne = ($EditorTabs, index) => {
-  $EditorTabs.firstChild.remove()
-  // const $EditorTab = $EditorTabs.children[index]
-  // $EditorTab.remove()
-}

package/static/0895dce/packages/renderer-process/src/parts/FindWidget/FindWidget.js

@@ -1,59 +0,0 @@
-import * as Focus from '../Focus/Focus.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-
-const handleInput = (event) => {
-  const $Target = event.target
-  const value = $Target.value
-  RendererWorker.send([
-    /* FindWidget.setValue  */ 'FindWidget.setValue',
-    /* value */ value,
-  ])
-}
-
-const handleClose = (event) => {
-  RendererWorker.send([/* FindWidget.dispose  */ 'FindWidget.dispose'])
-}
-
-const handleFocus = (event) => {
-  Focus.setFocus('findWidget')
-}
-
-export const create = (id) => {
-  const $FindWidgetInput = document.createElement('input')
-  $FindWidgetInput.className = 'FindWidgetInput'
-  $FindWidgetInput.oninput = handleInput
-  $FindWidgetInput.onfocus = handleFocus
-  // $FindWidgetInput.onblur = handleBlur
-  const $FindWidgetButtonClose = document.createElement('button')
-  $FindWidgetButtonClose.textContent = 'close'
-  $FindWidgetButtonClose.onclick = handleClose
-  const $FindWidget = document.createElement('div')
-  $FindWidget.className = 'FindWidget'
-  // $FindWidget.style.left = `${x}px`
-  // $FindWidget.style.top = `${y}px`
-  $FindWidget.dataset.widgetId = id
-  const $FindWidgetResults = document.createElement('div')
-  $FindWidgetResults.className = 'FindWidgetResults'
-  $FindWidget.append(
-    $FindWidgetInput,
-    $FindWidgetResults,
-    $FindWidgetButtonClose
-  )
-  const $Parent = document.querySelector('.OutputWidgets')
-  $Parent.append($FindWidget)
-  $FindWidgetInput.focus()
-  return {
-    $FindWidget,
-    $FindWidgetResults,
-    $FindWidgetInput,
-  }
-}
-
-export const dispose = (state) => {
-  state.$Viewlet.remove()
-}
-
-export const setResults = (state, results) => {
-  state.$FindWidgetResults.textContent =
-    results.length === 0 ? 'No Results' : `${results.length} results`
-}

package/static/0895dce/packages/renderer-process/src/parts/FocusHighlight/FocusHighlight.js

@@ -1,12 +0,0 @@
-export const highlightStart = ($Element) => {
-  $Element.classList.remove('Highlight')
-  requestAnimationFrame(() => {
-    $Element.classList.add('Highlight')
-  })
-
-  $Element.onanimationend = () => {
-    $Element.classList.remove('Highlight')
-  }
-}
-
-export const highlightStop = () => {}

package/static/0895dce/packages/renderer-process/src/parts/GlobalEventBus/GlobalEventBus.js

@@ -1,26 +0,0 @@
-// TODO global event bus is probably a bad idea
-// cons:
-// 1. it is not typesafe
-// 2. dependencies are unclear
-//
-// pros
-// 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
-
-export const state = {
-  listenerMap: Object.create(null),
-}
-
-export const emitEvent = (event, ...args) => {
-  const listeners = state.listenerMap[event] || []
-  for (const listener of listeners) {
-    listener(...args)
-  }
-}
-
-export const addListener = (event, fn) => {
-  state.listenerMap[event] ||= []
-  if (state.listenerMap[event].includes(fn)) {
-    return
-  }
-  state.listenerMap[event].push(fn)
-}

package/static/0895dce/packages/renderer-process/src/parts/KeyBindings/KeyBindings.js

@@ -1,154 +0,0 @@
-import * as Context from '../Context/Context.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-import * as Platform from '../Platform/Platform.js'
-
-const RE_ASCII = /[\p{ASCII}]+/u
-
-export const state = {
-  keyBindings: [],
-  modifier: '',
-  modifierTimeout: -1,
-}
-
-const isAscii = (key) => {
-  return RE_ASCII.test(key)
-}
-
-const getIdentifier = (event) => {
-  let identifier = ''
-  if (event.ctrlKey) {
-    identifier += 'ctrl+'
-  }
-  if (event.shiftKey) {
-    identifier += 'shift+'
-  }
-  if (event.altKey) {
-    identifier += 'alt+'
-  }
-  let key = event.key
-  if (key === ' ') {
-    key = 'Space'
-  }
-  if (key.length === 1) {
-    key = key.toLowerCase()
-  }
-  identifier += key
-  return identifier
-}
-
-// TODO store keybindings as json somewhere
-
-// TODO sort keybindings by `when` priority -> focus.editorCompletions: 10, focus.editor:9 etc.
-
-// TODO does it make sense to have all of these configurable?
-// could remove some context logic and have less user configuration when these are default
-// e.g. arrow down focuses next, arrow up always focuses previous item (like in aria spec)
-
-// TODO ui should only have keys -> commands get resolved inside renderer worker
-// TODO should toggle terminal, not only open
-
-const matchesContext = (keybinding) => {
-  if (!keybinding.when) {
-    return true
-  }
-  return Context.get(keybinding.when)
-}
-
-const getMatchingKeyBinding = (identifier) => {
-  // TODO this could be more efficient in O(N) instead of O(2N)
-  const matchesIdentifier = (keyBinding) => {
-    return keyBinding.key === identifier
-  }
-  const matchingKeyBindings = state.keyBindings.filter(matchesIdentifier)
-  const matchingKeyBinding = matchingKeyBindings.find(matchesContext)
-  return matchingKeyBinding
-}
-
-const getModifier = (event) => {
-  switch (event.key) {
-    case 'Control':
-      return 'ctrl'
-    case 'Shift':
-      return 'shift'
-    case 'Alt':
-      return 'alt'
-  }
-  return ''
-}
-
-const clearModifier = () => {
-  if (!state.modifier) {
-    return
-  }
-  if (state.modifierTimeout !== -1) {
-    clearTimeout(state.modifierTimeout)
-    state.modifier = ''
-    state.modifierTimeout = -1
-  }
-}
-
-const handleMatchingKeyBinding = (matchingKeyBinding) => {
-  // TODO execute command directly or -> executeCommand -> keybindings -> executeCommand
-  // better directly
-  // TODO always should be number
-  // when launching keybindings -> map string command to number
-  // TODO should args always be defined? (probably yes -> monomorphism & simpler code since all objects are the same)
-
-  // TODO matchingKeyBinding.command should always be number
-  RendererWorker.send([
-    /* KeyBindings.handleKeyBinding */ 'KeyBindings.handleKeyBinding',
-    /* keyBinding */ matchingKeyBinding,
-  ])
-}
-
-const handleKeyDown = (event) => {
-  const identifier = getIdentifier(event)
-  const matchingKeyBinding = getMatchingKeyBinding(identifier)
-  if (!matchingKeyBinding) {
-    return
-  }
-  event.preventDefault()
-  handleMatchingKeyBinding(matchingKeyBinding)
-}
-
-const handleKeyUp = (event) => {
-  const modifier = getModifier(event)
-  if (!modifier) {
-    clearModifier()
-    return
-  }
-  if (state.modifier === modifier) {
-    clearModifier()
-    const identifier = `${modifier} ${modifier}`
-    const matchingKeyBinding = getMatchingKeyBinding(identifier)
-    if (matchingKeyBinding) {
-      handleMatchingKeyBinding(matchingKeyBinding)
-    }
-    return
-  }
-
-  state.modifier = modifier
-  // @ts-ignore
-  state.modifierTimeout = setTimeout(clearModifier, 300)
-}
-
-export const hydrate = async (keyBindings) => {
-  // TODO is this the right place for browser context ?
-  // maybe in env file / env service
-  const browser = Platform.getBrowser()
-  Context.set(`browser.${browser}`, true)
-  state.keyBindings = keyBindings
-  window.addEventListener('keydown', handleKeyDown)
-  // TODO only need keyup listener if keybindings include double modifier key (e.g "shift shift")
-  window.addEventListener('keyup', handleKeyUp)
-}
-
-// TODO should be in renderer worker
-export const lookupKeyBinding = (commandId) => {
-  switch (commandId) {
-    case 'scm.acceptInput':
-      return 'Ctrl+Enter'
-    default:
-      return ''
-  }
-}