@lvce-editor/server 0.4.4 → 0.6.0

package/static/fbac85f/packages/renderer-worker/src/parts/TextDocument/TextDocument.js

@@ -0,0 +1,195 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Arrays from '../Arrays/Arrays.js'
+
+export const create = (text) => {
+  const lines = text.split('\n')
+  const state = {
+    lines,
+  }
+  // TODO send to shared process somehow
+  return state
+}
+
+// TODO have function for single edit (most common, avoid one array)
+export const applyEdits = (textDocument, changes) => {
+  Assert.object(textDocument)
+  Assert.array(changes)
+  // TODO don't copy all lines (can be expensive, e.g. 10000 lines = 10000 * 64bit = 64kB on every keystroke)
+  const newLines = [...textDocument.lines]
+  for (const change of changes) {
+    const startRowIndex = change.start.rowIndex
+    const endRowIndex = change.end.rowIndex
+    const startColumnIndex = change.start.columnIndex
+    const endColumnIndex = change.end.columnIndex
+    const inserted = change.inserted
+    const deleted = change.deleted
+    Assert.number(startRowIndex)
+    Assert.number(endRowIndex)
+    Assert.number(startColumnIndex)
+    Assert.number(endColumnIndex)
+    Assert.array(inserted)
+    Assert.array(deleted)
+    if (startRowIndex === endRowIndex) {
+      if (inserted.length === 0) {
+        const line = newLines[startRowIndex]
+        const before = line.slice(0, startColumnIndex)
+        const after = line.slice(endColumnIndex)
+        newLines[startRowIndex] = before + after
+      } else if (inserted.length === 1) {
+        const line = newLines[startRowIndex]
+        let before = line.slice(0, startColumnIndex)
+        if (startColumnIndex > line.length) {
+          before += ' '.repeat(startColumnIndex - line.length)
+        }
+        const after = line.slice(endColumnIndex)
+        const text = inserted[0]
+        newLines[startRowIndex] = before + text + after
+      } else {
+        const line = newLines[startRowIndex]
+        const before = line.slice(0, startColumnIndex) + inserted[0]
+        const after = inserted.at(-1) + line.slice(endColumnIndex)
+        Arrays.splice(newLines, startRowIndex, deleted.length, [
+          before,
+          ...inserted.slice(1, -1),
+          after,
+        ])
+        // TODO only do this once after all edits, not inside loop
+        textDocument.maxLineY = Math.min(
+          textDocument.numberOfVisibleLines,
+          newLines.length
+        )
+      }
+    } else {
+      if (inserted.length === 1) {
+        const before =
+          newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0]
+        const after =
+          endRowIndex >= newLines.length
+            ? ''
+            : newLines[endRowIndex].slice(endColumnIndex)
+        Arrays.splice(newLines, startRowIndex, deleted.length, [before + after])
+      } else {
+        const before =
+          newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0]
+        const middle = inserted.slice(1, -1)
+        const after =
+          inserted.at(-1) +
+          (endRowIndex >= newLines.length
+            ? ''
+            : newLines[endRowIndex].slice(endColumnIndex))
+        Arrays.splice(newLines, startRowIndex, deleted.length, [
+          before,
+          ...middle,
+          after,
+        ])
+      }
+      // TODO only do this once after all edits, not inside loop
+      textDocument.maxLineY = Math.min(
+        textDocument.numberOfVisibleLines,
+        textDocument.lines.length
+      )
+    }
+  }
+  return newLines
+}
+
+export const getLine = (textDocument, index) => {
+  return textDocument.lines[index]
+}
+
+export const getLineLength = (textDocument, index) => {
+  return textDocument.lines[index].length
+}
+
+export const getText = (state) => {
+  return state.lines.join('\n')
+}
+const RE_WHITESPACE = /^\s+/
+
+// TODO this doesn't belong here
+export const getIndent = (line) => {
+  const whitespaceMatch = line.match(RE_WHITESPACE)
+  if (!whitespaceMatch) {
+    return ''
+  }
+  return whitespaceMatch[0]
+}
+
+// TDOO this doesn;t belong here
+export const getSelectionText = (textDocument, range) => {
+  Assert.object(textDocument)
+  // console.log(range)
+  // console.log(textDocument)
+  const startRowIndex = range.start.rowIndex
+  const startColumnIndex = range.start.columnIndex
+  const endRowIndex = Math.min(
+    range.end.rowIndex,
+    textDocument.lines.length - 1
+  )
+  const endColumnIndex = range.end.columnIndex
+
+  if (startRowIndex === endRowIndex) {
+    // console.log(startRowIndex)
+    // console.log(textDocument.lines)
+    return [
+      textDocument.lines[startRowIndex].slice(startColumnIndex, endColumnIndex),
+    ]
+  }
+  const selectedLines = [
+    textDocument.lines[startRowIndex].slice(startColumnIndex),
+    ...textDocument.lines.slice(startRowIndex + 1, endRowIndex),
+    textDocument.lines[endRowIndex].slice(0, endColumnIndex),
+  ]
+  return selectedLines
+}
+
+export const offsetAt = (
+  textDocument,
+  positionRowIndex,
+  positionColumnIndex
+) => {
+  Assert.object(textDocument)
+  Assert.number(positionRowIndex)
+  Assert.number(positionColumnIndex)
+  let offset = 0
+  let rowIndex = 0
+  const lines = textDocument.lines
+  const max = Math.min(positionRowIndex, textDocument.lines.length)
+  while (rowIndex < max) {
+    offset += lines[rowIndex].length + 1
+    rowIndex++
+  }
+  offset += positionColumnIndex
+  return offset
+}
+
+export const positionAt = (textDocument, offset) => {
+  // console.log({ textDocument, offset })
+  let rowIndex = 0
+  let columnIndex = 0
+  let currentOffset = 0
+  while (rowIndex < textDocument.lines.length && currentOffset < offset) {
+    textDocument
+    currentOffset += textDocument.lines[rowIndex].length + 1
+    rowIndex++
+  }
+
+  if (currentOffset > offset) {
+    rowIndex
+    rowIndex--
+    currentOffset -= textDocument.lines[rowIndex].length + 1
+    columnIndex = offset - currentOffset
+  } else {
+    columnIndex = currentOffset - offset
+  }
+  currentOffset
+  offset
+  // for (let i = 0; i < textDocument.lines.length; i++) {
+  // if(currentOffset)
+  // }
+  // TODO
+  return {
+    rowIndex,
+    columnIndex,
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TextDocumentSearch/TextDocumentSearch.js

@@ -0,0 +1,47 @@
+export const findMatches = (lines, searchString) => {
+  const { length } = lines
+  const matches = []
+  for (let i = 0; i < length; i++) {
+    const line = lines[i]
+    const index = line.indexOf(searchString)
+    if (index !== -1) {
+      matches.push(i, index)
+    }
+  }
+  return new Uint32Array(matches)
+}
+
+export const findNextMatch = (lines, searchString, startRowIndex) => {
+  const { length } = lines
+  for (let i = startRowIndex; i < length; i++) {
+    const line = lines[i]
+    const index = line.indexOf(searchString)
+    if (index !== -1) {
+      return {
+        rowIndex: i,
+        columnIndex: index,
+      }
+    }
+  }
+  return {
+    rowIndex: 0,
+    columnIndex: 0,
+  }
+}
+
+export const findPreviousMatch = (lines, searchString, startRowIndex) => {
+  for (let i = startRowIndex; i >= 0; i--) {
+    const line = lines[i]
+    const index = line.indexOf(searchString)
+    if (index !== -1) {
+      return {
+        rowIndex: i,
+        columnIndex: index,
+      }
+    }
+  }
+  return {
+    rowIndex: 0,
+    columnIndex: 0,
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TextSearch/TextSearch.js

@@ -0,0 +1,31 @@
+import * as Assert from '../Assert/Assert.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+
+const getProvider = (scheme) => {
+  console.log({ scheme })
+  switch (scheme) {
+    case '':
+      return import('./TextSearchNode.js')
+    case 'web':
+      return import('./TextSearchWeb.js')
+    default:
+      return import('./TextSearchExtension.js')
+  }
+}
+
+export const textSearch = async (root, query) => {
+  Assert.string(root)
+  Assert.string(query)
+  const scheme = FileSystem.getProtocol(root)
+  const provider = await getProvider(scheme)
+  const results = await provider.textSearch(scheme, root, query)
+  return results
+}
+
+export const cancel = async (searchId) => {
+  // TODO
+  // await SharedProcess.invoke(
+  //   /* Search.cancel */ 'Search.cancel',
+  //   /* searchId */ state.searchId
+  // )
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TextSearch/TextSearchWeb.js

@@ -0,0 +1,21 @@
+import * as FileSystemWeb from '../FileSystem/FileSystemWeb.js'
+
+export const textSearch = (scheme, root, query) => {
+  const entries = Object.entries(FileSystemWeb.state.files)
+  const results = []
+  console.log(entries)
+  for (const [key, value] of entries) {
+    if (value.includes(query)) {
+      results.push([
+        key,
+        [
+          {
+            absoluteOffset: 0,
+            preview: value,
+          },
+        ],
+      ])
+    }
+  }
+  return results
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.ipc.js

@@ -0,0 +1,24 @@
+import * as TitleBarMenuBar from './TitleBarMenuBar.js'
+import * as MenuIpc from '../Menu/Menu.ipc.js'
+
+// prettier-ignore
+export const Commands = {
+  'TitleBarMenuBar.closeMenu': TitleBarMenuBar.closeMenu,
+  'TitleBarMenuBar.focus': TitleBarMenuBar.focus,
+  'TitleBarMenuBar.focusIndex': TitleBarMenuBar.focusIndex,
+  'TitleBarMenuBar.focusNext': TitleBarMenuBar.focusNext,
+  'TitleBarMenuBar.focusPrevious': TitleBarMenuBar.focusPrevious,
+  'TitleBarMenuBar.handleKeyArrowDown': TitleBarMenuBar.handleKeyArrowDown,
+  'TitleBarMenuBar.handleKeyArrowLeft': TitleBarMenuBar.handleKeyArrowLeft,
+  'TitleBarMenuBar.handleKeyArrowRight': TitleBarMenuBar.handleKeyArrowRight,
+  'TitleBarMenuBar.handleKeyArrowUp': TitleBarMenuBar.handleKeyArrowUp,
+  'TitleBarMenuBar.handleKeyEnd': TitleBarMenuBar.handleKeyEnd,
+  'TitleBarMenuBar.handleKeyEnter': TitleBarMenuBar.handleKeyEnter,
+  'TitleBarMenuBar.handleKeyEscape': TitleBarMenuBar.handleKeyEscape,
+  'TitleBarMenuBar.handleKeyHome': TitleBarMenuBar.handleKeyHome,
+  'TitleBarMenuBar.handleKeySpace': TitleBarMenuBar.handleKeySpace,
+  'TitleBarMenuBar.hydrate': TitleBarMenuBar.hydrate,
+  'TitleBarMenuBar.openMenu': TitleBarMenuBar.openMenu,
+  'TitleBarMenuBar.toggleIndex': TitleBarMenuBar.toggleIndex,
+  ...MenuIpc.Commands,
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.js

@@ -0,0 +1,252 @@
+// TODO menu should not be needed initially, only when item is selected and menu is opened
+import * as Menu from '../Menu/Menu.js'
+import * as MenuEntries from '../MenuEntries/MenuEntries.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
+
+export const state = {
+  /**
+   * @type{any[]}
+   */
+  titleBarEntries: [],
+  focusedIndex: 0,
+  isMenuOpen: false,
+}
+
+// TODO put this in json (e.g. defaultTitleBarMenu.json) and load from cache storage or via ajax
+// TODO only compute once if is electron and filter out during build process
+
+export const getEntries = async () => {
+  state.titleBarEntries = await MenuEntries.getMenuEntries(MenuEntryId.TitleBar)
+  return state.titleBarEntries
+}
+
+/**
+ * @param {number} index
+ * @param {boolean} shouldBeFocused
+ */
+const openMenuAtIndex = async (index, shouldBeFocused) => {
+  // TODO race conditions
+  // TODO send renderer process
+  // 1. open menu, items to show
+  // 2. focus menu
+  const id = state.titleBarEntries[index].id
+  const items = await MenuEntries.getMenuEntries(id)
+  Menu.state.menus = []
+  const bounds = await RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'TitleBar',
+    /* method */ 'menuGetEntryBounds',
+    /* index */ index
+  )
+  // TODO race condition: another menu might already be open at this point
+
+  const x = bounds.left
+  const y = bounds.bottom
+  const width = Menu.getMenuWidth()
+  const height = Menu.getMenuHeight(items)
+  const menuFocusedIndex = shouldBeFocused
+    ? Menu.getIndexToFocusNextStartingAt(items, 0)
+    : -1
+  const menu = Menu.addMenuInternal({
+    id,
+    items,
+    focusedIndex: menuFocusedIndex,
+    level: Menu.state.menus.length,
+    x,
+    y,
+  })
+  RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'TitleBar',
+    /* method */ 'menuOpen',
+    /* unFocusIndex */ state.focusedIndex,
+    /* index */ index,
+    /* level */ menu.level,
+    /* menuItems */ menu.items,
+    /* menuFocusedIndex */ menuFocusedIndex,
+    /* focus */ shouldBeFocused,
+    /* x */ x,
+    /* y */ y,
+    /* width */ width,
+    /* height */ height
+  )
+  state.isMenuOpen = true
+}
+
+/**
+ * @param {boolean} focus
+ */
+export const openMenu = async (focus) => {
+  if (state.focusedIndex === -1) {
+    return
+  }
+  await openMenuAtIndex(state.focusedIndex, focus)
+}
+
+export const closeMenu = async (keepFocus) => {
+  // TODO send to renderer process
+  // 1. close menu
+  // 2. focus top level entry
+  const focusIndex = keepFocus ? state.focusedIndex : -1
+  // TODO use Viewlet.dispose instead
+  state.isMenuOpen = false
+  await RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'TitleBar',
+    /* method */ 'menuClose',
+    /* unFocusIndex */ state.focusedIndex,
+    /* focusIndex */ focusIndex
+  )
+}
+
+export const toggleMenu = async () => {
+  if (state.isMenuOpen) {
+    closeMenu(/* keepFocus */ true)
+  } else {
+    await openMenu(/* focus */ false)
+  }
+}
+
+export const focusIndex = async (index) => {
+  if (state.isMenuOpen) {
+    await openMenuAtIndex(index, /* focus */ false)
+  } else {
+    await RendererProcess.invoke(
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'TitleBar',
+      /* menuFocusIndex */ 'menuFocusIndex',
+      /* unFocusIndex */ state.focusedIndex,
+      /* index */ index
+    )
+  }
+  state.focusedIndex = index
+}
+
+export const toggleIndex = async (index) => {
+  if (state.isMenuOpen && state.focusedIndex === index) {
+    closeMenu(/* keepFocus */ true)
+  } else {
+    await openMenuAtIndex(index, /* focus */ false)
+  }
+  state.focusedIndex = index
+}
+
+export const focus = async () => {
+  await focusFirst()
+}
+
+const getIndexToFocusPreviousStartingAt = (items, index) => {
+  return (index + items.length) % items.length
+}
+
+export const focusPrevious = async () => {
+  const indexToFocus = getIndexToFocusPreviousStartingAt(
+    state.titleBarEntries,
+    state.focusedIndex - 1
+  )
+  await focusIndex(indexToFocus)
+}
+
+const getIndexToFocusNextStartingAt = (items, index) => {
+  return index % items.length
+}
+
+export const focusNext = async () => {
+  const indexToFocus = getIndexToFocusNextStartingAt(
+    state.titleBarEntries,
+    state.focusedIndex + 1
+  )
+  await focusIndex(indexToFocus)
+}
+
+export const focusFirst = async () => {
+  const indexToFocus = getIndexToFocusNextStartingAt(state.titleBarEntries, 0)
+  await focusIndex(indexToFocus)
+}
+
+export const focusLast = async () => {
+  const indexToFocus = getIndexToFocusPreviousStartingAt(
+    state.titleBarEntries,
+    state.titleBarEntries.length - 1
+  )
+  await focusIndex(indexToFocus)
+}
+
+export const handleKeyArrowLeft = async () => {
+  if (state.isMenuOpen && Menu.state.menus.length > 1) {
+    return
+  }
+  // TODO menu collapse
+  await focusPrevious()
+}
+
+export const handleKeyArrowUp = () => {
+  if (!state.isMenuOpen) {
+    return
+  }
+  Menu.focusPrevious()
+}
+
+export const handleKeyArrowRight = async () => {
+  console.log('arrow right')
+  if (state.isMenuOpen) {
+    // if menu can open sub menu to the right -> do that
+    const menu = Menu.state.menus.at(-1)
+    const item = menu.items[menu.focusedIndex]
+    if (item.flags === /* SubMenu */ 4) {
+      await Menu.showSubMenu(Menu.state.menus.length - 1, menu.focusedIndex)
+      return
+    }
+  }
+  await focusNext()
+}
+
+export const handleKeyHome = async () => {
+  if (state.isMenuOpen) {
+    Menu.focusFirst()
+  } else {
+    await focusFirst()
+  }
+}
+
+// TODO this is also use for pagedown -> maybe find a better name for this function
+export const handleKeyEnd = async () => {
+  if (state.isMenuOpen) {
+    Menu.focusLast()
+  } else {
+    await focusLast()
+  }
+}
+
+// TODO this is same as handle key enter -> merge the functions
+export const handleKeySpace = async () => {
+  if (state.isMenuOpen) {
+    await Menu.selectCurrent()
+  } else {
+    openMenu(/* focus */ true)
+  }
+}
+
+export const handleKeyEnter = async () => {
+  if (state.isMenuOpen) {
+    await Menu.selectCurrent()
+  } else {
+    openMenu(/* focus */ true)
+  }
+}
+
+export const handleKeyEscape = () => {
+  if (!state.isMenuOpen) {
+    return
+  }
+  closeMenu(/* keepFocus */ true)
+}
+
+export const handleKeyArrowDown = async () => {
+  if (state.isMenuOpen) {
+    Menu.focusNext()
+  } else {
+    await openMenu(/* focus */ true)
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/Url/Url.ipc.js

@@ -0,0 +1,6 @@
+import * as Url from './Url.js'
+
+export const Commands = {
+  'Url.createObjectUrl': Url.createObjectUrl,
+  'Url.revokeObjectUrl': Url.revokeObjectUrl,
+}

package/static/fbac85f/packages/renderer-worker/src/parts/Url/Url.js

@@ -0,0 +1,7 @@
+export const createObjectUrl = (blob) => {
+  return URL.createObjectURL(blob)
+}
+
+export const revokeObjectUrl = (url) => {
+  return URL.revokeObjectURL(url)
+}

package/static/fbac85f/packages/renderer-worker/src/parts/VError/VError.js

@@ -0,0 +1,28 @@
+const getCombinedMessage = (error, message) => {
+  if (message) {
+    return `${message}: ${error}`
+  }
+  return `${error}`
+}
+
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = parent.indexOf('\n')
+  const childNewLineIndex = child.indexOf('\n')
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  return parentFirstLine + childRest
+}
+
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack)
+    }
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/Viewlet/Viewlet.ipc.js

@@ -0,0 +1,8 @@
+import * as Viewlet from './Viewlet.js'
+
+export const Commands = {
+  'Viewlet.closeWidget': Viewlet.closeWidget,
+  'Viewlet.getAllStates': Viewlet.getAllStates,
+  'Viewlet.openWidget': Viewlet.openWidget,
+  2133: Viewlet.send,
+}