@lvce-editor/server 0.4.4 → 0.6.0

package/static/3d96d42/packages/renderer-process/src/parts/ModuleMap/ModuleMap.js

@@ -1,134 +0,0 @@
-import * as ModuleId from '../ModuleId/ModuleId.js'
-
-export const getModuleId = (commandId) => {
-  switch (commandId) {
-    case 'Audio.play':
-      return ModuleId.Audio
-    case 'ClipBoard.readText':
-    case 'ClipBoard.writeText':
-      return ModuleId.ClipBoard
-    case 'Css.setInlineStyle':
-      return ModuleId.Css
-    case 'Developer.getMemoryUsage':
-    case 'Developer.showState':
-      return ModuleId.Developer
-    case 'Dialog.alert':
-    case 'Dialog.close':
-    case 'Dialog.prompt':
-    case 'Dialog.showErrorDialogWithOptions':
-      return ModuleId.Dialog
-    case 'Download.downloadFile':
-      return ModuleId.Download
-    case 764:
-    case 765:
-    case 766:
-    case 767:
-    case 768:
-    case 769:
-    case 770:
-    case 771:
-    case 772:
-    case 773:
-    case 774:
-    case 775:
-    case 776:
-    case 777:
-      return ModuleId.EditorController
-    case 'EditorError.create':
-      return ModuleId.EditorError
-    case 'EditorHover.create':
-      return ModuleId.EditorHover
-    case 'EditorRename.create':
-    case 'EditorRename.dispose':
-    case 'EditorRename.finish':
-      return ModuleId.EditorRename
-    case 'FindWidget.create':
-    case 'FindWidget.dispose':
-    case 'FindWidget.setResults':
-      return ModuleId.FindWidget
-    case 'ImagePreview.create':
-    case 'ImagePreview.dispose':
-    case 'ImagePreview.showError':
-    case 'ImagePreview.update':
-      return ModuleId.ImagePreview
-    case 'InitData.getInitData':
-      return ModuleId.InitData
-    case 'KeyBindings.hydrate':
-      return ModuleId.KeyBindings
-    case 'Layout.getBounds':
-    case 'Layout.hide':
-    case 'Layout.hydrate':
-    case 'Layout.show':
-    case 'Layout.update':
-      return ModuleId.Layout
-    case 'Location.getHref':
-    case 'Location.getPathName':
-    case 'Location.hydrate':
-    case 'Location.setPathName':
-      return ModuleId.Location
-    case 'Menu.focusIndex':
-    case 'Menu.hide':
-    case 'Menu.hideSubMenu':
-    case 'Menu.show':
-    case 'Menu.showContextMenu':
-    case 'Menu.showControlled':
-    case 'Menu.showMenu':
-    case 'Menu.showSubMenu':
-      return ModuleId.Menu
-    case 'Meta.setThemeColor':
-      return ModuleId.Meta
-    case 'Notification.create':
-    case 'Notification.createWithOptions':
-    case 'Notification.dispose':
-      return ModuleId.Notification
-    case 'Open.openUrl':
-      return ModuleId.Open
-    case 6661:
-    case 6662:
-    case 6663:
-    case 6664:
-      return ModuleId.Panel
-    case 'ServiceWorker.register':
-    case 'ServiceWorker.uninstall':
-      return ModuleId.ServiceWorker
-    case 'TestFrameWork.checkMultiElementCondition':
-    case 'TestFrameWork.checkSingleElementCondition':
-    case 'TestFrameWork.performAction':
-    case 'TestFrameWork.performKeyBoardAction':
-    case 'TestFrameWork.showOverlay':
-      return ModuleId.TestFrameWork
-    case 549:
-    case 550:
-    case 551:
-      return ModuleId.ViewService
-    case 'Viewlet.appendViewlet':
-    case 'Viewlet.dispose':
-    case 'Viewlet.focus':
-    case 'Viewlet.handleError':
-    case 'Viewlet.invoke':
-    case 'Viewlet.load':
-    case 'Viewlet.refresh':
-    case 'Viewlet.send':
-    case 'Viewlet.sendMultiple':
-      return ModuleId.Viewlet
-    case 'WebStorage.clear':
-    case 'WebStorage.getItem':
-    case 'WebStorage.setItem':
-      return ModuleId.WebStorage
-    case 'Window.close':
-    case 'Window.maximize':
-    case 'Window.minimize':
-    case 'Window.onVisibilityChange':
-    case 'Window.reload':
-    case 'Window.setTitle':
-    case 'Window.unmaximize':
-      return ModuleId.Window
-    case 33111:
-      return ModuleId.Workbench
-    case 'Performance.measureUserAgentSpecificMemory':
-    case 'Performance.getMemory':
-      return ModuleId.Performance
-    default:
-      throw new Error(`command ${commandId} not found`)
-  }
-}

package/static/3d96d42/packages/renderer-process/src/parts/OldMenu/Menu.js

@@ -1,336 +0,0 @@
-import * as FindIndex from '../../shared/findIndex.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-import * as Widget from '../Widget/Widget.js'
-import * as MenuItem from '../MenuItem/MenuItem.js'
-import * as BackDrop from '../BackDrop/BackDrop.js'
-import * as Focus from '../Focus/Focus.js'
-
-// TODO when pressing tab -> focus next element in tab order and close menu
-
-// TODO menu and contextmenu should have own keybinding logic
-// seems not possible to do with just one keybinding listener
-
-// TODO similar to context menu, show sub menu entries
-// there can be multiple instances (parent -> child -> child) submenus
-
-// TODO using .style.top, .style.left causes chrome devtools to show many layout shift -> maybe use transform instead
-
-// TODO when cycling through items, recalculate style is much slower
-// than in vscode (1.49ms vs 0.33ms)
-// paint is also faster in vscode (0.32ms vs 0.14ms)
-
-// TODO focus on menu is not announced to screenreader
-
-// TODO recalculate style and paint is slow when cycling through items:
-// 0.59ms recalculate style
-// 36us update layer tree
-// 0.35ms paint
-// 0.20ms composite layer
-
-// const contextMenuWidth = 150
-// const contextMenuHeight = 150 + /* padding */ 8 * 4
-
-// TODO keyboard handling
-
-export const state = {
-  handleKeyDown(event) {},
-  handleFocusOut(event) {},
-  $$Menus: [],
-  anchorX: 0,
-  anchorY: 0,
-  anchorTime: -1,
-  $BackDrop: undefined,
-}
-
-const getLevel = ($Menu) => {
-  return state.$$Menus.indexOf($Menu)
-}
-
-const handleMouseDown = (event) => {
-  const $Target = event.target
-  const $Menu = $Target.closest('.Menu')
-  const index = FindIndex.findIndex($Menu, $Target)
-  if (index === -1) {
-    console.log('index is negative one')
-    return
-  }
-  event.preventDefault()
-  const level = getLevel($Menu)
-  RendererWorker.send(
-    /* Menu.handleClick */ 'Menu.selectIndex',
-    /* level */ level,
-    /* index */ index
-  )
-}
-
-// const handleKeyDown = (event) => {
-//   console.log({ key: event.key })
-//   switch (event.key) {
-//     case 'ArrowUp':
-//       RendererWorker.send( /* Menu.focusPrevious */ 7405)
-//       break
-//     case 'ArrowLeft':
-//       // TODO collapse menu maybe
-//       break
-//     case 'ArrowDown':
-//       RendererWorker.send( /* Menu.focusNext */ 7404)
-//       break
-//     case 'ArrowRight':
-//       // TODO expand sub menu maybe
-//       break
-//     case 'Home':
-//       RendererWorker.send( /* Menu.focusFirst */ 7406)
-//       break
-//     case 'End':
-//       RendererWorker.send( /* Menu.focusLast */ 7407)
-//       break
-//     default:
-//       break
-//   }
-// }
-
-const MOUSE_LOCS_TRACKED = 3
-
-/**
- *
- * @param {MouseEvent} event
- */
-const handleMouseEnter = (event) => {
-  const $Target = event.target
-  // @ts-ignore
-  const $Menu = $Target.closest('.Menu')
-  const x = event.clientX
-  const y = event.clientY
-  const timeStamp = event.timeStamp
-
-  const index = FindIndex.findIndex($Menu, $Target)
-  if (index === -1) {
-    return
-  }
-  const level = getLevel($Menu)
-  RendererWorker.send(
-    /* Menu.handleMouseEnter */ 'Menu.handleMouseEnter',
-    /* level */ level,
-    /* index */ index,
-    /* x */ x,
-    /* y */ y,
-    /* timeStamp */ timeStamp
-  )
-}
-
-const handleMouseMove = (event) => {
-  // const x = event.clientX
-  // const y = event.clientY
-  // console.log('move', { x, y })
-}
-
-const handleMouseLeave = (event) => {
-  const $RelatedTarget = event.relatedTarget
-  if ($RelatedTarget.classList.contains('MenuItem')) {
-    return
-  }
-  RendererWorker.send(/* Menu.handleMouseLeave */ 'Menu.handleMouseLeave')
-}
-
-// const handleBlur = (event) => {}
-const handleKeyDown = (event) => {
-  state.handleKeyDown(event)
-}
-
-const handleFocusOut = (event) => {
-  state.handleFocusOut(event)
-}
-
-const create$Menu = () => {
-  // TODO set aria label on menu (e.g. File, Edit, Selection)
-  const $Menu = document.createElement('ul')
-  $Menu.className = 'Menu'
-  // @ts-ignore
-  $Menu.role = 'menu'
-  $Menu.tabIndex = -1
-  // $ContextMenu.onmousedown = contextMenuHandleMouseDown
-  // TODO mousedown vs click? (click is usually better but mousedown is faster, why wait 100ms?)
-  $Menu.addEventListener('mousedown', handleMouseDown)
-  $Menu.addEventListener('mouseenter', handleMouseEnter, {
-    capture: true,
-  })
-  $Menu.addEventListener('mouseleave', handleMouseLeave, {
-    capture: true,
-  })
-  // $Menu.addEventListener('mousemove', handleMouseMove, {
-  //   passive: true,
-  // })
-  $Menu.onkeydown = handleKeyDown
-  $Menu.addEventListener('focusout', handleFocusOut)
-  $Menu.oncontextmenu = handleContextMenu
-  // $ContextMenu.onfocus = handleFocus
-  // $ContextMenu.onblur = handleBlur
-  return $Menu
-}
-
-export const focusIndex = (level, oldFocusedIndex, newFocusedIndex) => {
-  const $Menu = state.$$Menus[level]
-  if (oldFocusedIndex !== -1) {
-    $Menu.children[oldFocusedIndex].classList.remove('Focused')
-  }
-  if (newFocusedIndex !== -1) {
-    $Menu.children[newFocusedIndex].classList.add('Focused')
-    $Menu.children[newFocusedIndex].focus()
-  }
-}
-
-// TODO replace function that recycles menu dom nodes
-
-const handleBackDropMouseDown = () => {
-  RendererWorker.send(/* Menu.hide */ 'Menu.hide')
-}
-
-const handleContextMenu = (event) => {
-  event.preventDefault()
-}
-
-export const showMenu = (
-  x,
-  y,
-  width,
-  height,
-  items,
-  level,
-  parentIndex = -1,
-  mouseBlocking = false
-) => {
-  if (mouseBlocking) {
-    const $BackDrop = BackDrop.create$BackDrop()
-    $BackDrop.onmousedown = handleBackDropMouseDown
-    $BackDrop.oncontextmenu = handleContextMenu
-    state.$BackDrop = $BackDrop
-    Widget.append($BackDrop)
-  }
-
-  const $Menu = create$Menu()
-  $Menu.append(...items.map(MenuItem.create$MenuItem))
-  $Menu.style.left = `${x}px`
-  $Menu.style.top = `${y}px`
-  $Menu.id = `Menu-${level}`
-
-  if (parentIndex !== -1) {
-    const $ParentMenu = state.$$Menus[level - 1]
-    const $ParentMenuItem = $ParentMenu.children[parentIndex]
-    $ParentMenuItem.ariaExpanded = 'true'
-    $ParentMenuItem.setAttribute('aria-owns', $Menu.id)
-  }
-
-  state.$$Menus.push($Menu)
-  Widget.append($Menu)
-
-  if (level === 0) {
-    Focus.focus($Menu, 'menu')
-  }
-}
-
-export const showContextMenu = (x, y, width, height, level, items) => {
-  for (const $Menu of state.$$Menus) {
-    Widget.remove($Menu)
-  }
-  state.$$Menus = []
-  while (state.$$Menus.length > 0) {
-    state.$$Menus[0].remove()
-  }
-  const $Menu = create$Menu()
-  $Menu.append(...items.map(MenuItem.create$MenuItem))
-  $Menu.style.left = `${x}px`
-  $Menu.style.top = `${y}px`
-  $Menu.id = `Menu-${level}`
-  Widget.append($Menu)
-  state.$$Menus.push($Menu)
-  // TODO create backdrop
-}
-
-export const closeSubMenu = () => {
-  const $SubMenu = state.$$Menus.pop()
-  const $ParentMenu = state.$$Menus.at(-1)
-  Widget.remove($SubMenu)
-}
-
-export const hideSubMenu = (level) => {
-  const $$ChildMenus = state.$$Menus.slice(level)
-  for (const $ChildMenu of $$ChildMenus) {
-    Widget.remove($ChildMenu)
-  }
-}
-
-// export const showSubMenu = (level, items, parentIndex) => {
-//   const $$ChildMenus = state.$$Menus.slice(level)
-//   for (const $ChildMenu of $$ChildMenus) {
-//     Widget.remove($ChildMenu)
-//   }
-//   state.$$Menus = state.$$Menus.slice(0, level)
-//   const $ParentMenu = state.$$Menus[level - 1]
-//   const $ParentMenuItem = $ParentMenu.children[parentIndex]
-//   const rect = $ParentMenuItem.getBoundingClientRect()
-//   const x = rect.right
-//   const y = rect.top
-//   showMenu(x, y, items, level)
-//   // TODO remove aria-owns when sub-menu is closed
-//   $ParentMenuItem.setAttribute('aria-owns', 'Menu')
-// }
-
-// TODO implement focusIndex like this
-// const focusIndex2=(id, index)=>{
-//   const $Menu = state.menus[id]
-//   $Menu.children[index].focus()
-// }
-
-// TODO support nested menus / submenus
-export const showControlled = ({
-  x,
-  y,
-  items,
-  handleKeyDown,
-  handleFocusOut,
-  $Parent,
-  level,
-  width,
-  height,
-}) => {
-  showMenu(x, y, width, height, items, level)
-  // TODO menu should not necessarily know about parent (titleBarMenuBar)
-  // it should be the other way around
-  state.$Parent = $Parent
-  state.handleFocusOut = handleFocusOut
-  state.handleKeyDown = handleKeyDown
-  if ($Parent) {
-    // state.$Menu.ariaLabel=''
-    // state.$Menu.ariaLabelledBy  =$Parent.id
-    $Parent.setAttribute('aria-owns', 'Menu')
-  } else {
-    // state.$Menu.removeAttribute('aria-labelledby')
-  }
-  // Context.setFocus('menu') // TODO overlapping focus: titleBarMenuBar has focus (kinda) but also menu at the same time
-}
-
-// TODO have function to show submenu
-
-export const hide = (restoreFocus = true) => {
-  for (const $Menu of state.$$Menus) {
-    Widget.remove($Menu)
-  }
-  state.$$Menus = []
-  if (state.$BackDrop) {
-    Widget.remove(state.$BackDrop)
-    state.$BackDrop = undefined
-  }
-  // TODO focus previous item
-  if (restoreFocus) {
-    Focus.focusPrevious()
-  }
-}
-
-export const contains = ($Element) => {
-  for (const $Menu of state.$$Menus) {
-    if ($Menu.contains($Element)) {
-      return true
-    }
-  }
-  return false
-}

package/static/3d96d42/packages/renderer-process/src/parts/Performance/Performance.ipc.js

@@ -1,7 +0,0 @@
-import * as Performance from './Performance.js'
-
-// prettier-ignore
-export const Commands = {
-  'Performance.measureUserAgentSpecificMemory': Performance.measureUserAgentSpecificMemory,
-  'Performance.getMemory': Performance.getMemory,
-}

package/static/3d96d42/packages/renderer-process/src/parts/Platform/Platform.js

@@ -1,107 +0,0 @@
-import * as PlatformType from '../PlatformType/PlatformType.js'
-/* istanbul ignore file */
-
-// TODO this should always be completely tree shaken out during build
-
-/**
- * @returns {'electron'|'remote'|'web'}
- */
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof 'remote' !== 'undefined') {
-    // @ts-ignore
-    return 'remote'
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return PlatformType.Remote
-  }
-  // @ts-ignore
-  const userAgentData = navigator.userAgentData
-  // TODO this is probably a bad check but electron doesn't deliver anything and
-  // this will be tree shaken out anyway during build
-  if (userAgentData && userAgentData.brands.length === 0) {
-    return PlatformType.Electron
-  }
-  return PlatformType.Remote
-}
-
-export const platform = getPlatform()
-
-// TODO treeshake this function out when targeting electron
-
-export const state = {
-  getAssetDir() {
-    // @ts-ignore
-    if (typeof '/3d96d42' !== 'undefined') {
-      // @ts-ignore
-      return '/3d96d42'
-    }
-    if (platform === 'electron') {
-      return '../../../../..'
-    }
-    return ''
-  },
-  supportsHtml5Dialog() {
-    const $Dialog = document.createElement('dialog')
-    // @ts-ignore
-    return typeof $Dialog.showModal === 'function'
-  },
-  isElectron() {
-    return (
-      // @ts-ignore
-      window.myApi &&
-      // @ts-ignore
-      window.myApi.ipcConnect &&
-      // @ts-ignore
-      typeof window.myApi.ipcConnect === 'function'
-    )
-  },
-}
-
-// TODO if necessary support more browser detection
-export const getBrowser = () => {
-  if (platform === 'electron') {
-    return 'electron'
-  }
-  // @ts-ignore
-  const userAgentData = navigator.userAgentData
-  if (userAgentData) {
-    for (const brand of userAgentData.brands) {
-      const actualBrand = brand.brand.toLowerCase()
-      switch (actualBrand) {
-        case 'firefox':
-          return 'firefox'
-        case 'chromium':
-          return 'chromium'
-        default:
-          break
-      }
-    }
-  }
-  const userAgent = navigator.userAgent.toLowerCase()
-  if (userAgent.includes('firefox')) {
-    return 'firefox'
-  }
-  if (userAgent.includes('Electron')) {
-    return 'electron'
-  }
-  return 'chromium'
-}
-
-export const getAssetDir = () => {
-  return state.getAssetDir()
-}
-
-export const supportsHtml5Dialog = () => {
-  return state.supportsHtml5Dialog()
-}
-
-export const isElectron = () => {
-  return state.isElectron()
-}
-
-export const getRendererWorkerUrl = () => {
-  const assetDir = getAssetDir()
-  const urlRendererWorker = `${assetDir}/packages/renderer-worker/dist/rendererWorkerMain.js`
-  return urlRendererWorker
-}

package/static/3d96d42/packages/renderer-process/src/parts/TestFrameWork/ConditionErrors.js

@@ -1,81 +0,0 @@
-import * as QuerySelector from './QuerySelector.js'
-
-export const toBeVisible = (locator) => {
-  return `expected selector to be visible ${locator._selector}`
-}
-
-const printLocator = (locator) => {
-  if (locator._nth) {
-    return `${locator._selector}:nth(${locator._nth})`
-  }
-  return `${locator._selector}`
-}
-
-export const toHaveText = (locator, { text }) => {
-  const element = QuerySelector.querySelectorWithOptions(locator._selector, {
-    nth: locator._nth,
-    hasText: locator._hasText,
-  })
-  const locatorString = printLocator(locator)
-  if (!element) {
-    return `expected selector ${locatorString} to have text "${text}" element was not found`
-  }
-  return `expected selector ${locatorString} to have text "${text}" but was "${element.textContent}"`
-}
-
-export const toHaveAttribute = (locator, { key, value }) => {
-  const element = QuerySelector.querySelectorWithOptions(locator._selector, {
-    nth: locator._nth,
-    hasText: locator._hasText,
-  })
-  const locatorString = printLocator(locator)
-  if (!element) {
-    return `expected ${locatorString} to have attribute ${key} ${value} but element was not found`
-  }
-  const actual = element.getAttribute(key)
-  return `expected ${locatorString} to have attribute ${key} ${value} but was ${actual}`
-}
-
-export const toHaveCount = (locator, { count }) => {
-  const locatorString = printLocator(locator)
-  return `expected ${locatorString} to have count ${count}`
-}
-
-export const toBeFocused = (locator) => {
-  const locatorString = printLocator(locator)
-  return `expected ${locatorString} to be focused`
-}
-
-export const toHaveClass = (locator, { className }) => {
-  const [element] = QuerySelector.querySelector(locator._selector)
-  const locatorString = printLocator(locator)
-  if (!element) {
-    return `expected ${locatorString} to have class ${className} but element was not found`
-  }
-  return `expected ${locatorString} to have class ${className}`
-}
-
-export const toHaveId = (locator, { id }) => {
-  const [element] = QuerySelector.querySelector(locator._selector)
-  const locatorString = printLocator(locator)
-  if (!element) {
-    return `expected ${locatorString} to have id ${id} but element was not found`
-  }
-  return `expected ${locatorString} to have id ${id}`
-}
-
-export const toBeHidden = (locator) => {
-  const locatorString = printLocator(locator)
-  return `expected ${locatorString} to be hidden`
-}
-
-export const toHaveCss = (locator, { key, value }) => {
-  const [element] = QuerySelector.querySelector(locator._selector)
-  const locatorString = printLocator(locator)
-  if (!element) {
-    return `expected ${locatorString} to have css ${key} ${value}`
-  }
-  const style = getComputedStyle(element)
-  const actual = style[key]
-  return `expected ${locatorString} to have css ${key} ${value} but was ${actual}`
-}