@lvce-editor/server 0.0.27 → 0.0.28

package/static/f9b8874/packages/renderer-worker/src/parts/TestFrameWork/TestFrameWork.js

@@ -0,0 +1,264 @@
+import * as Command from '../Command/Command.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+export { create as Locator } from './Locator.js'
+
+export const getTmpDir = async () => {
+  return `memfs://`
+}
+
+const querySelectorByText = (root, text) => {
+  let node
+  const elements = []
+  const walk = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null)
+  while ((node = walk.nextNode())) {
+    // @ts-ignore
+    if (node.nodeValue === text) {
+      elements.push(node.parentNode)
+    }
+  }
+  return elements
+}
+
+const querySelectorByCss = (selector) => {
+  return Array.from(document.querySelectorAll(selector))
+}
+
+const querySelector = (selector) => {
+  if (typeof selector !== 'string') {
+    throw new Error('selector must be of type string')
+  }
+  if (selector.startsWith('text=')) {
+    return querySelectorByText(document.body, selector.slice('text='.length))
+  }
+  if (selector.includes('text=')) {
+    const index = selector.indexOf('text=')
+    const elements = querySelectorByCss(selector.slice(0, index))
+    const text = selector.slice(index + 'text='.length)
+    return elements.flatMap((element) => {
+      return querySelectorByText(element, text)
+    })
+    // for(const element of elements)
+  }
+  if (selector.startsWith('.')) {
+    return querySelectorByCss(selector)
+  }
+  if (selector.startsWith('#')) {
+    return querySelectorByCss(selector)
+  }
+  throw new Error(`unsupported selector: ${selector}`)
+}
+
+const querySelectorWithOptions = (
+  selector,
+  { nth = -1, hasText = '' } = {}
+) => {
+  let elements = querySelector(selector)
+  if (hasText) {
+    elements = elements.filter((element) => element.textContent === hasText)
+  }
+  if (elements.length === 0) {
+    return undefined
+  }
+  if (elements.length === 1) {
+    const element = elements[0]
+    return element
+  }
+  if (nth === -1) {
+    throw new Error(`too many matching elements for ${selector}`)
+  }
+  const element = elements[nth]
+  if (!element) {
+    throw new Error(`selector not found: ${selector}`)
+  }
+  return element
+}
+
+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 }
+}
+
+const createKeyBoard = () => {
+  return {
+    async press(key) {
+      const element = document.activeElement
+      const keyOptions = getKeyOptions(key)
+      const options = {
+        cancelable: true,
+        bubbles: true,
+        ...keyOptions,
+      }
+      ElementActions.keyDown(element, options)
+      ElementActions.keyUp(element, options)
+    },
+  }
+}
+
+const waitForReady = async () => {
+  //   const startTime = Time.getTimeStamp()
+  //   const endTime = startTime + maxTimeout
+  //   let currentTime = startTime
+  //   while (currentTime < endTime) {
+  //     const element = querySelectorWithOptions(
+  //       '.ActivityBarItem[title="Explorer"]'
+  //     )
+  //     if (element) {
+  //       return
+  //     }
+  //     await Timeout.waitForMutation(100)
+  //     currentTime = Time.getTimeStamp()
+  //   }
+  // throw new Error(`Main element not found`)
+}
+
+export const test = async (name, fn) => {
+  let _error
+  let _start
+  let _end
+  let _duration
+  try {
+    await waitForReady()
+    _start = performance.now()
+    await fn()
+    _end = performance.now()
+    _duration = `${_end - _start}ms`
+    console.info(`[test passed] ${name} in ${_duration}`)
+  } catch (error) {
+    _error = error.message
+    error.message = `Test failed: ${name}: ${error.message}`
+    console.error(error)
+  }
+  let state
+  let background
+  let text
+  if (_error) {
+    state = 'fail'
+    background = 'red'
+    text = `test failed: ${_error}`
+  } else {
+    background = 'green'
+    text = `test passed in ${_duration}`
+    state = 'pass'
+  }
+  await RendererProcess.invoke(
+    'TestFrameWork.showOverlay',
+    state,
+    background,
+    text
+  )
+}
+
+test.skip = async (id, fn) => {
+  const state = 'skip'
+  const background = 'yellow'
+  const text = `test skipped ${id}`
+  await RendererProcess.invoke(
+    'TestFrameWork.showOverlay',
+    state,
+    background,
+    text
+  )
+}
+
+const Assert = {
+  string(value, message) {
+    if (typeof value !== 'string') {
+      throw new Error(message)
+    }
+  },
+  number(value, message) {
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new Error(message)
+    }
+  },
+}
+
+export const expect = (locator) => {
+  return {
+    async checkSingleElementCondition(fnName, options) {
+      Assert.string(fnName)
+      return RendererProcess.invoke(
+        'TestFrameWork.checkSingleElementCondition',
+        locator,
+        fnName,
+        options
+      )
+    },
+    async checkMultiElementCondition(fnName, options) {
+      return RendererProcess.invoke(
+        'TestFrameWork.checkMultiElementCondition',
+        locator,
+        fnName,
+        options
+      )
+    },
+    async toBeVisible() {
+      return this.checkSingleElementCondition('toBeVisible', {})
+    },
+    async toHaveText(text) {
+      Assert.string(text, 'text must be of type string')
+      return this.checkSingleElementCondition('toHaveText', { text })
+    },
+    async toBeFocused() {
+      return this.checkSingleElementCondition('toBeFocused')
+    },
+    async toHaveCSS(key, value) {
+      return this.checkSingleElementCondition('toHaveCss', {
+        key,
+        value,
+      })
+    },
+    async toHaveAttribute(key, value) {
+      Assert.string(key, 'key must be of type string')
+      // Assert.string(value, 'value must be of type string')
+      return this.checkSingleElementCondition('toHaveAttribute', {
+        key,
+        value,
+      })
+    },
+    async toHaveClass(className) {
+      Assert.string(className, 'className must be of type string')
+      return await this.checkSingleElementCondition('toHaveClass', {
+        className,
+      })
+    },
+    async toHaveCount(count) {
+      Assert.number(count, 'count must be of type string')
+      return this.checkMultiElementCondition('toHaveCount', { count })
+    },
+    async toBeHidden() {
+      return this.checkMultiElementCondition('toBeHidden', {})
+    },
+    get not() {
+      this.negated = true
+      return this
+    },
+  }
+}

package/static/f9b8874/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/f9b8874/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/f9b8874/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentEditor.js

@@ -0,0 +1,21 @@
+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)
+}

package/static/f9b8874/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/f9b8874/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/f9b8874/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/f9b8874/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/f9b8874/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/f9b8874/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/f9b8874/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)
+  }
+}