@lvce-editor/server 0.0.26 → 0.0.29

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

@@ -0,0 +1,129 @@
+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/bf7d47a/packages/renderer-process/src/parts/Editor/LayerSelections.js

@@ -0,0 +1,90 @@
+import * as Platform from '../Platform/Platform.js'
+
+const create$Selection = () => {
+  const $Selection = document.createElement('div')
+  $Selection.className = 'EditorSelection'
+  return $Selection
+}
+
+const render$Selection = ($Selection, selections, i) => {
+  const top = selections[i * 4]
+  const left = selections[i * 4 + 1]
+  const width = selections[i * 4 + 2]
+  const height = selections[i * 4 + 3]
+  // TODO have many decorations per row
+  // no absolute positioning
+  $Selection.style.top = `${top}px`
+  $Selection.style.left = `${left}px`
+  $Selection.style.width = `${width}px`
+  $Selection.style.height = `${height}px`
+}
+
+const render$SelectionsLess = (
+  $Selections,
+  childCount,
+  selections,
+  selectionCount
+) => {
+  for (let i = 0, j = 0; i < childCount; i++, j += 4) {
+    render$Selection($Selections.children[i], selections[i])
+  }
+  const fragment = document.createDocumentFragment()
+  for (let i = childCount; i < selectionCount; i++) {
+    const $Selection = create$Selection()
+    render$Selection($Selection, selections, i)
+    fragment.append($Selection)
+  }
+  $Selections.append(fragment)
+}
+
+const render$SelectionsEqual = (
+  $Selections,
+  childCount,
+  selections,
+  selectionCount
+) => {
+  for (let i = 0; i < selectionCount; i++) {
+    render$Selection($Selections.children[i], selections, i)
+  }
+}
+
+const render$SelectionsMore = (
+  $Selections,
+  childCount,
+  selections,
+  selectionCount
+) => {
+  for (let i = 0; i < selectionCount; i++) {
+    render$Selection($Selections.children[i], selections, i)
+  }
+  const diff = childCount - selectionCount
+  for (let i = 0; i < diff; i++) {
+    $Selections.lastChild.remove()
+  }
+}
+
+const render$Selections = ($Selections, selections) => {
+  const selectionsCount = selections.length / 4
+  const childCount = $Selections.children.length
+  if (childCount < selectionsCount) {
+    render$SelectionsLess($Selections, childCount, selections, selectionsCount)
+  } else if (childCount === selectionsCount) {
+    render$SelectionsEqual($Selections, childCount, selections, selectionsCount)
+  } else {
+    render$SelectionsMore($Selections, childCount, selections, selectionsCount)
+  }
+}
+
+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/bf7d47a/packages/renderer-process/src/parts/EditorGroup/EditorGroup.js

@@ -0,0 +1,55 @@
+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/bf7d47a/packages/renderer-process/src/parts/EditorRename/EditorRename.js

@@ -0,0 +1,39 @@
+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/bf7d47a/packages/renderer-process/src/parts/EditorTab/EditorTab.js

@@ -0,0 +1,129 @@
+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')
+  // @ts-ignore
+  $Tab.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/bf7d47a/packages/renderer-process/src/parts/Errors/JsonRpcError.js

@@ -0,0 +1,6 @@
+export class JsonRpcError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'JsonRpcError'
+  }
+}

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

@@ -0,0 +1,59 @@
+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/bf7d47a/packages/renderer-process/src/parts/InitData/InitData.ipc.js

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

package/static/bf7d47a/packages/renderer-process/src/parts/InitData/InitData.js

@@ -0,0 +1,18 @@
+import * as Location from '../Location/Location.js'
+import * as Layout from '../Layout/Layout.js'
+
+export const getInitData = () => {
+  const initData = {
+    Location: {
+      href: Location.getHref(),
+    },
+    Layout: {
+      bounds: Layout.getBounds(),
+    },
+    LocalStorage: {
+      savedState: localStorage.getItem('stateToSave'),
+      layout: localStorage.getItem('layout'),
+    },
+  }
+  return initData
+}

package/static/bf7d47a/packages/renderer-process/src/parts/IpcParent/IpcParent.js

@@ -0,0 +1,30 @@
+// TODO lazyload these files
+import * as IpcParentWithMessagePort from './IpcParentWithMessagePort.js'
+import * as IpcParentWithModuleWorker from './IpcParentWithModuleWorker.js'
+import * as IpcParentWithReferencePort from './IpcParentWithReferencePort.js'
+
+/* istanbul ignore file */
+
+export const Methods = {
+  MessagePort: 1,
+  ModuleWorker: 2,
+  ReferencePort: 3,
+}
+
+/**
+ * @type {number}
+ */
+const METHOD_PREFERRED = Methods.ModuleWorker
+
+export const create = async ({ method, ...options }) => {
+  switch (METHOD_PREFERRED) {
+    case Methods.ModuleWorker:
+      return IpcParentWithModuleWorker.create(options)
+    case Methods.MessagePort:
+      return IpcParentWithMessagePort.create(options)
+    case Methods.ReferencePort:
+      return IpcParentWithReferencePort.create(options)
+    default:
+      throw new Error('unknown method')
+  }
+}

package/static/bf7d47a/packages/renderer-process/src/parts/IpcParent/IpcParentWithMessagePort.js

@@ -0,0 +1,11 @@
+import * as Assert from '../Assert/Assert.js'
+
+export const create = async ({ url }) => {
+  Assert.string(url)
+  const port = await new Promise((resolve) => {
+    globalThis.acceptPort = resolve
+    import(url)
+  })
+  delete globalThis.acceptPort
+  return port
+}