@lvce-editor/server 0.0.26 → 0.0.29

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponent.js

@@ -0,0 +1,8 @@
+export * as ContextMenu from './TestFrameWorkComponentContextMenu.js'
+export * as Editor from './TestFrameWorkComponentEditor.js'
+export * as Explorer from './TestFrameWorkComponentExplorer.js'
+export * as Extension from './TestFrameWorkComponentExtension.js'
+export * as FileSystem from './TestFrameWorkComponentFileSystem.js'
+export * as Main from './TestFrameWorkComponentMain.js'
+export * as Workspace from './TestFrameWorkComponentWorkspace.js'
+export * as KeyBoard from './TestFrameWorkComponentKeyBoard.js'

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentContextMenu.js

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const selectItem = async (text) => {
+  await Command.execute('Menu.selectItem', text)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentEditor.js

@@ -0,0 +1,49 @@
+import * as Command from '../Command/Command.js'
+
+export const setCursor = async (rowIndex, columnIndex) => {
+  await Command.execute('Editor.cursorSet', rowIndex, columnIndex)
+}
+
+export const openCompletion = async () => {
+  await Command.execute('Editor.openCompletion')
+}
+
+export const openEditorContextMenu = async () => {
+  await Command.execute('Editor.handleContextMenu', 0, 0)
+}
+
+export const executeTabCompletion = async () => {
+  await Command.execute('Editor.tabCompletion')
+}
+
+export const executeBraceCompletion = async (text) => {
+  await Command.execute('Editor.braceCompletion', text)
+}
+
+export const cursorCharacterRight = async () => {
+  await Command.execute('Editor.cursorCharacterRight')
+}
+
+export const cursorCharacterLeft = async () => {
+  await Command.execute('Editor.cursorCharacterLeft')
+}
+
+export const copyLineDown = async () => {
+  await Command.execute('Editor.copyLineDown')
+}
+
+export const cursorDown = async () => {
+  await Command.execute('Editor.cursorDown')
+}
+
+export const cursorUp = async () => {
+  await Command.execute('Editor.cursorUp')
+}
+
+export const cursorWordLeft = async () => {
+  await Command.execute('Editor.cursorWordLeft')
+}
+
+export const cursorWordRight = async () => {
+  await Command.execute('Editor.cursorWordRight')
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentExplorer.js

@@ -0,0 +1,9 @@
+import * as Command from '../Command/Command.js'
+
+export const openContextMenu = async (index) => {
+  await Command.execute('Explorer.handleContextMenu', 0, 0, index)
+}
+
+export const focus = async () => {
+  await Command.execute('Explorer.focusIndex', -1)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentExtension.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+
+export const addWebExtension = async (relativePath) => {
+  // TODO compute absolutePath
+  const absolutePath = relativePath
+  await Command.execute('ExtensionMeta.addWebExtension', absolutePath)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentFileSystem.js

@@ -0,0 +1,13 @@
+import * as Command from '../Command/Command.js'
+
+export const writeFile = async (path, content) => {
+  await Command.execute('FileSystem.writeFile', path, content)
+}
+
+export const mkdir = async (path) => {
+  await Command.execute('FileSystem.mkdir', path)
+}
+
+export const getTmpDir = async () => {
+  return 'memfs://'
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentKeyBoard.js

@@ -0,0 +1,47 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+const getKeyOptions = (rawKey) => {
+  if (rawKey.includes('+')) {
+    const parts = rawKey.split('+')
+    let ctrlKey = false
+    let altKey = false
+    let spaceKey = false
+    let key = ''
+    for (const part of parts) {
+      switch (part) {
+        case 'Control':
+          ctrlKey = true
+          break
+        case 'Space':
+          key = ' '
+          break
+        case 'Alt':
+          altKey = true
+          break
+        default:
+          key = part
+          break
+      }
+    }
+    return {
+      key,
+      ctrlKey,
+      altKey,
+    }
+  }
+  return { key: rawKey }
+}
+
+export const press = async (key) => {
+  const keyOptions = getKeyOptions(key)
+  const options = {
+    cancelable: true,
+    bubbles: true,
+    ...keyOptions,
+  }
+  await RendererProcess.invoke(
+    'TestFrameWork.performKeyBoardAction',
+    'press',
+    options
+  )
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentMain.js

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const openUri = async (uri) => {
+  await Command.execute('Main.openUri', uri)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentWorkspace.js

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const setPath = async (path) => {
+  await Command.execute('Workspace.setPath', path)
+}

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

@@ -0,0 +1,197 @@
+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)
+        console.log({ before, after })
+        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))
+        console.log({ before, after })
+        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/bf7d47a/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.ipc.js

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

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

@@ -0,0 +1,249 @@
+// 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'
+
+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('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(
+      /* TitleBarMenuBar.focusIndex */ 1371,
+      /* 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)
+  }
+}