@lvce-editor/server 0.4.4 → 0.6.0

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

@@ -1,407 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-// TODO lazyload menuEntries and use Command.execute (maybe)
-import * as Layout from '../Layout/Layout.js'
-import * as MenuEntries from '../MenuEntries/MenuEntries.js'
-import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
-
-export const state = {
-  /**
-   * @type {any[]}
-   */
-  menus: [],
-  latestTimeStamp: 0,
-  enterTimeout: -1,
-}
-
-const MENU_WIDTH = 150
-
-const CONTEXT_MENU_ITEM_HEIGHT = 28
-const CONTEXT_MENU_SEPARATOR_HEIGHT = 6
-const CONTEXT_MENU_PADDING = 20
-const CONTEXT_MENU_WIDTH = 250
-
-export const getMenuWidth = () => {
-  return CONTEXT_MENU_WIDTH
-}
-
-export const getMenuHeight = (items) => {
-  let height = CONTEXT_MENU_PADDING
-  for (const item of items) {
-    switch (item.flags) {
-      case /* ContextMenuItemSeparator */ 1:
-        height += CONTEXT_MENU_SEPARATOR_HEIGHT
-        break
-      default:
-        height += CONTEXT_MENU_ITEM_HEIGHT
-        break
-    }
-  }
-  return height
-}
-
-const getCurrentMenu = () => {
-  if (state.menus.length === 0) {
-    console.warn('menu not available')
-  }
-  return state.menus.at(-1)
-}
-
-export const addMenuInternal = (menu) => {
-  if (state.menus.length > 5) {
-    throw new Error('too many menus')
-  }
-  state.menus.push(menu)
-  return menu
-}
-
-export const addRootMenuInternal = (menu) => {
-  state.menus = [menu]
-  return menu
-}
-
-const getMenuBounds = (x, y, items) => {
-  const menuWidth = CONTEXT_MENU_WIDTH
-  const menuHeight = getMenuHeight(items)
-
-  const windowWidth = Layout.state.windowWidth
-  const windowHeight = Layout.state.windowHeight
-  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
-  // TODO what about separators?
-
-  if (x + menuWidth > windowWidth) {
-    x -= menuWidth
-  }
-  if (y + menuHeight > windowHeight) {
-    y -= menuHeight
-  }
-
-  return {
-    x,
-    y,
-    width: menuWidth,
-    height: menuHeight,
-  }
-}
-
-export const show = async (x, y, id, mouseBlocking = false) => {
-  const items = await MenuEntries.getMenuEntries(id)
-  const bounds = getMenuBounds(x, y, items)
-  const menu = addMenuInternal({
-    id,
-    items,
-    focusedIndex: -1,
-    level: state.menus.length,
-    x: bounds.x,
-    y: bounds.y,
-  })
-  await RendererProcess.invoke(
-    /* Menu.show */ 'Menu.showMenu',
-    /* x */ bounds.x,
-    /* y */ bounds.y,
-    /* width */ bounds.width,
-    /* height */ bounds.height,
-    /* items */ menu.items,
-    /* level */ menu.level,
-    /* parentIndex */ -1,
-    /* mouseBlocking */ mouseBlocking
-  )
-}
-
-export const closeSubMenu = () => {
-  const menu = state.menus.pop()
-  const parentMenu = state.menus.at(-1)
-  RendererProcess.invoke(
-    /* Menu.hideSubMenu */ 7903,
-    /* parentIndex */ parentMenu.focusedIndex
-  )
-}
-
-const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
-  // TODO delete old menus
-  state.menus = state.menus.slice(0, level + 1)
-  const parentMenu = state.menus[level]
-  const item = parentMenu.items[index]
-  const subMenuItems = await MenuEntries.getMenuEntries(item.id)
-  const subMenu = addMenuInternal({
-    id: item.id,
-    items: subMenuItems,
-    focusedIndex: -1,
-    level: state.menus.length,
-    y: parentMenu.y + index * 25,
-    x: parentMenu.x + MENU_WIDTH,
-    enterX,
-    enterY,
-  })
-  const width = getMenuWidth()
-  const height = getMenuHeight(subMenuItems)
-  RendererProcess.invoke(
-    /* Menu.showMenu */ 'Menu.showMenu',
-    /* x */ subMenu.x,
-    /* y */ subMenu.y,
-    /* width */ width,
-    /* height */ height,
-    /* items */ subMenu.items,
-    /* level */ subMenu.level,
-    /* parentIndex */ index
-  )
-}
-
-export const showSubMenu = async (level, index) => {
-  await showSubMenuAtEnter(level, index, -1, -1)
-}
-
-const selectIndexNone = async (item) => {
-  if (!item.command) {
-    console.warn('item has missing command', item)
-    return
-  }
-  const args = item.args || []
-  await Promise.all([
-    hide(/* restoreFocus */ false),
-    Command.execute(item.command, ...args),
-  ])
-}
-
-const selectIndexRestoreFocus = async (item) => {
-  if (!item.command) {
-    console.warn('item has missing command', item)
-    return
-  }
-  const args = item.args || []
-  await Promise.all([
-    hide(/* restoreFocus */ true),
-    Command.execute(item.command, ...args),
-  ])
-}
-
-const selectIndexSubMenu = async (menu, index) => {
-  if (menu.focusedIndex === index) {
-    return
-  }
-  await showSubMenu(menu.level, menu.focusedIndex)
-}
-
-export const selectIndex = async (level, index) => {
-  const menu = state.menus[level]
-  menu.focusedIndex = index
-  const item = menu.items[menu.focusedIndex]
-  switch (item.flags) {
-    case MenuItemFlags.None:
-      return selectIndexNone(item)
-    case MenuItemFlags.SubMenu:
-      return selectIndexSubMenu(menu, index)
-    case MenuItemFlags.RestoreFocus:
-      return selectIndexRestoreFocus(item)
-    default:
-      break
-  }
-}
-
-export const selectItem = (text) => {
-  for (let level = 0; level < state.menus.length; level++) {
-    const menu = state.menus[level]
-    for (let i = 0; i < menu.items.length; i++) {
-      const item = menu.items[i]
-      if (item.label === text) {
-        return selectIndex(level, i)
-      }
-    }
-  }
-  throw new Error(`menu item not found: ${text}`)
-}
-
-export const selectCurrent = async (level) => {
-  const menu = state.menus[level]
-  await selectIndex(level, menu.focusedIndex)
-}
-
-export const hide = async (restoreFocus = true) => {
-  if (state.menus.length === 0) {
-    return
-  }
-  state.menus = []
-  await RendererProcess.invoke(
-    /* Menu.hide */ 'Menu.hide',
-    /* restoreFocus */ restoreFocus
-  )
-}
-
-// TODO difference between focusing with mouse or keyboard
-// with mouse -> open submenu
-// with keyboard -> don't open submenu, only focus
-
-const hideSubMenus = async (level) => {
-  if (level < state.menus.length) {
-    state.menus = state.menus.slice(0, level + 1)
-    await RendererProcess.invoke(
-      /* Menu.hideSubMenu */ 'Menu.hideSubMenu',
-      /* level */ level + 1
-    )
-  }
-}
-
-const MENU_DELAY_TRIANGLE = 300
-
-const resolveAfterTimeout = (fn) => {
-  setTimeout(fn, MENU_DELAY_TRIANGLE)
-}
-
-export const handleMouseEnter = async (
-  level,
-  index,
-  enterX,
-  enterY,
-  enterTimeStamp
-) => {
-  state.latestTimeStamp = enterTimeStamp
-  if (level >= state.menus.length) {
-    return
-  }
-  const menu = state.menus[level]
-  if (menu.focusedIndex === index) {
-    return
-  }
-  if (level < state.menus.length - 1) {
-    const subMenu = state.menus[level + 1]
-    const subMenuEnterX = subMenu.enterX
-    // TODO should check for triangle position here
-    if (enterX >= subMenuEnterX) {
-      await new Promise(resolveAfterTimeout)
-      if (state.latestTimeStamp !== enterTimeStamp) {
-        return
-      }
-    }
-  }
-  const item = menu.items[index]
-  await focusIndex(menu, index)
-  switch (item.flags) {
-    case /* SubMenu */ 4:
-      await showSubMenuAtEnter(menu.level, index, enterX, enterY)
-      break
-    default:
-      await hideSubMenus(menu.level)
-      break
-  }
-}
-
-export const handleMouseLeave = async () => {
-  const menu = state.menus[0]
-  if (menu.items.length === 0) {
-    return
-  }
-  const oldFocusedIndex = menu.focusedIndex
-  menu.focusedIndex = -1
-  await RendererProcess.invoke(
-    /* Menu.focusIndex */ 'Menu.focusIndex',
-    /* level */ menu.level,
-    /* oldFocusedIndex */ oldFocusedIndex,
-    /* newFocusedIndex */ -1
-  )
-}
-
-export const focusIndex = async (menu, index) => {
-  if (menu.items.length === 0) {
-    return
-  }
-  const oldFocusedIndex = menu.focusedIndex
-  menu.focusedIndex = index
-  await RendererProcess.invoke(
-    /* Menu.focusIndex */ 'Menu.focusIndex',
-    /* level */ menu.level,
-    /* oldFocusedIndex */ oldFocusedIndex,
-    /* newFocusedIndex */ index
-  )
-}
-
-export const getIndexToFocusNextStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i < startIndex + items.length; i++) {
-    const index = i % items.length
-    const item = items[index]
-    if (canBeFocused(item)) {
-      return index
-    }
-  }
-  console.log({ startIndex, items })
-  return -1
-}
-
-export const focusFirst = async () => {
-  const menu = getCurrentMenu()
-  if (menu.items.length === 0) {
-    return
-  }
-  const indexToFocus = getIndexToFocusNextStartingAt(menu.items, 0)
-  console.log({ first: indexToFocus })
-  await focusIndex(menu, indexToFocus)
-}
-
-export const focusLast = async () => {
-  const menu = getCurrentMenu()
-  const indexToFocus = getIndexToFocusPreviousStartingAt(
-    menu.items,
-    menu.items.length - 1
-  )
-  await focusIndex(menu, indexToFocus)
-}
-
-// TODO this code seems a bit too complicated, maybe it can be simplified
-const getIndexToFocusPreviousStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i > startIndex - items.length; i--) {
-    const index = (i + items.length) % items.length
-    const item = items[index]
-    if (canBeFocused(item)) {
-      return index
-    }
-  }
-  return -1
-}
-
-const getIndexToFocusPrevious = (menu) => {
-  const startIndex =
-    menu.focusedIndex === -1 ? menu.items.length - 1 : menu.focusedIndex - 1
-  return getIndexToFocusPreviousStartingAt(menu.items, startIndex)
-}
-
-export const focusPrevious = async () => {
-  const menu = getCurrentMenu()
-  if (menu.items.length === 0) {
-    return
-  }
-  const indexToFocus = getIndexToFocusPrevious(menu)
-  await focusIndex(menu, indexToFocus)
-}
-
-const canBeFocused = (item) => {
-  switch (item.flags) {
-    case MenuItemFlags.Separator:
-    case MenuItemFlags.Disabled:
-      return false
-    default:
-      return true
-  }
-}
-
-const getIndexToFocusNext = (menu) => {
-  const startIndex = menu.focusedIndex + 1
-  return getIndexToFocusNextStartingAt(menu.items, startIndex)
-}
-
-export const focusNext = async () => {
-  const menu = getCurrentMenu()
-  if (menu.items.length === 0) {
-    return
-  }
-  const indexToFocus = getIndexToFocusNext(menu)
-  await focusIndex(menu, indexToFocus)
-}
-
-export const resetFocusedIndex = (menu) => {
-  menu.focusedIndex = -1
-}
-
-// TODO handle printable letter and focus item that starts with that letter
-
-// TODO pageup / pagedown keys
-
-// TODO more tests

package/static/3d96d42/packages/renderer-worker/src/parts/MenuCore/MenuCore.js

@@ -1,52 +0,0 @@
-import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
-
-export const getIndexToFocusNextStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i < startIndex + items.length; i++) {
-    const index = i % items.length
-    const item = items[index]
-    if (canBeFocused(item)) {
-      return index
-    }
-    console.log({ index, item })
-  }
-  console.log({ startIndex, items })
-  return -1
-}
-
-export const getIndexToFocusFirst = (menu) => {
-  return getIndexToFocusNextStartingAt(menu.items, 0)
-}
-
-// TODO this code seems a bit too complicated, maybe it can be simplified
-const getIndexToFocusPreviousStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i > startIndex - items.length; i--) {
-    const index = (i + items.length) % items.length
-    const item = items[index]
-    if (canBeFocused(item)) {
-      return index
-    }
-  }
-  return -1
-}
-
-export const getIndexToFocusLast = (menu) => {
-  return getIndexToFocusPreviousStartingAt(menu.items, menu.items.length - 1)
-}
-
-export const getIndexToFocusPrevious = (menu) => {
-  const startIndex =
-    menu.focusedIndex === -1 ? menu.items.length - 1 : menu.focusedIndex - 1
-  return getIndexToFocusPreviousStartingAt(menu.items, startIndex)
-}
-
-const canBeFocused = (item) => {
-  return (
-    item.flags !== MenuItemFlags.Separator &&
-    item.flags !== MenuItemFlags.Disabled
-  )
-}
-
-export const getIndexToFocusNext = (menu) => {
-  const startIndex = menu.focusedIndex + 1
-  return getIndexToFocusNextStartingAt(menu.items, startIndex)
-}

package/static/3d96d42/packages/renderer-worker/src/parts/MenuEntries/MenuEntries.js

@@ -1,47 +0,0 @@
-const getModule = (id) => {
-  switch (id) {
-    case 'activityBar':
-      return import('./MenuEntriesActivityBar.js')
-    case 'edit':
-      return import('./MenuEntriesEdit.js')
-    case 'editor':
-      return import('./MenuEntriesEditor.js')
-    case 'explorer':
-      return import('./MenuEntriesExplorer.js')
-    case 'file':
-      return import('./MenuEntriesFile.js')
-    case 'go':
-      return import('./MenuEntriesGo.js')
-    case 'help':
-      return import('./MenuEntriesHelp.js')
-    case 'manageExtension':
-      return import('./MenuEntriesManageExtension.js')
-    case 'openRecent':
-      return import('./MenuEntriesOpenRecent.js')
-    case 'run':
-      return import('./MenuEntriesRun.js')
-    case 'selection':
-      return import('./MenuEntriesSelection.js')
-    case 'settings':
-      return import('./MenuEntriesSettings.js')
-    case 'tab':
-      return import('./MenuEntriesTab.js')
-    case 'terminal':
-      return import('./MenuEntriesTerminal.js')
-    case 'titleBar':
-      return import('./MenuEntriesTitleBar.js')
-    case 'view':
-      return import('./MenuEntriesView.js')
-    case 'activity-bar-additional-views':
-      return import('./MenuEntriesActivityBarAdditionalViews.js')
-    case 'search':
-      return import('./MenuEntriesSearch.js')
-    default:
-      throw new Error(`module not found "${id}"`)
-  }
-}
-
-export const getMenuEntries = async (id) => {
-  const module = await getModule(id)
-  return module.getMenuEntries()
-}

package/static/3d96d42/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesExplorer.js

@@ -1,147 +0,0 @@
-import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as I18nString from '../I18NString/I18NString.js'
-import * as DirentType from '../DirentType/DirentType.js'
-import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
-
-export const UiStrings = {
-  NewFile: 'New File',
-  NewFolder: 'New Folder',
-  OpenContainingFolder: 'Open Containing Folder',
-  OpenInIntegratedTerminal: 'Open in integrated Terminal',
-  Separator: 'Separator',
-  Cut: 'Cut',
-  Copy: 'Copy',
-  Paste: 'Paste',
-  CopyPath: 'Copy Path',
-  CopyRelativePath: 'Copy Relative Path',
-  Rename: 'Rename',
-  Delete: 'Delete',
-}
-
-const ALL_ENTRIES = [
-  {
-    id: 'newFile',
-    label: I18nString.i18nString(UiStrings.NewFile),
-    flags: MenuItemFlags.None,
-    command: 'Explorer.newFile',
-  },
-  {
-    id: 'newFolder',
-    label: I18nString.i18nString(UiStrings.NewFolder),
-    flags: MenuItemFlags.None,
-    command: 'Explorer.newFolder',
-  },
-  {
-    id: 'openContainingFolder',
-    label: I18nString.i18nString(UiStrings.OpenContainingFolder),
-    flags: MenuItemFlags.RestoreFocus,
-    command: 'Explorer.openContainingFolder',
-  },
-  {
-    id: 'openInIntegratedTerminal',
-    label: I18nString.i18nString(UiStrings.OpenInIntegratedTerminal),
-    flags: MenuItemFlags.None,
-    command: /* TODO */ -1,
-  },
-  {
-    id: '',
-    label: I18nString.i18nString(UiStrings.Separator),
-    flags: MenuItemFlags.Separator,
-    command: /* TODO */ -1,
-  },
-  {
-    id: 'cut',
-    label: I18nString.i18nString(UiStrings.Cut),
-    flags: MenuItemFlags.RestoreFocus,
-    command: /* TODO */ -1,
-  },
-  {
-    id: 'copy',
-    label: I18nString.i18nString(UiStrings.Copy),
-    flags: MenuItemFlags.RestoreFocus,
-    command: 'Explorer.handleCopy',
-  },
-  {
-    id: 'paste',
-    label: I18nString.i18nString(UiStrings.Paste),
-    flags: MenuItemFlags.None,
-    command: 'Explorer.handlePaste',
-  },
-  {
-    id: '',
-    label: I18nString.i18nString(UiStrings.Separator),
-    flags: MenuItemFlags.Separator,
-    command: /* TODO */ -1,
-  },
-  {
-    id: 'copyPath',
-    label: I18nString.i18nString(UiStrings.CopyPath),
-    flags: MenuItemFlags.RestoreFocus,
-    command: 'Explorer.copyPath',
-  },
-  {
-    id: 'copyRelativePath',
-    label: I18nString.i18nString(UiStrings.CopyRelativePath),
-    flags: MenuItemFlags.RestoreFocus,
-    command: 'Explorer.copyRelativePath',
-  },
-  {
-    id: '',
-    label: I18nString.i18nString(UiStrings.Separator),
-    flags: MenuItemFlags.Separator,
-    command: /* TODO */ -1,
-  },
-  {
-    id: 'rename',
-    label: I18nString.i18nString(UiStrings.Rename),
-    flags: MenuItemFlags.None,
-    command: 'Explorer.renameDirent',
-  },
-  {
-    id: 'delete',
-    label: I18nString.i18nString(UiStrings.Delete),
-    flags: MenuItemFlags.None,
-    command: 'Explorer.removeDirent',
-  },
-]
-
-const isFileEntry = (entry) => {
-  return entry.id !== 'newFile' && entry.id !== 'newFolder'
-}
-
-// TODO there are two possible ways of getting the focused dirent of explorer
-// 1. directly access state of explorer (bad because it directly accesses state of another component)
-// 2. expose getFocusedDirent method in explorer (bad because explorer code should not know about for menuEntriesExplorer, which needs that method)
-const getFocusedDirent = () => {
-  const explorerState = Viewlet.getState('Explorer')
-  if (!explorerState || explorerState.focusedIndex < 0) {
-    return undefined
-  }
-  return explorerState.dirents[explorerState.focusedIndex]
-}
-
-const getMenuEntriesDirectory = () => {
-  return ALL_ENTRIES
-}
-const getMenuEntriesFile = () => {
-  return ALL_ENTRIES.filter(isFileEntry)
-}
-
-const getMenuEntriesDefault = () => {
-  return ALL_ENTRIES
-}
-
-export const getMenuEntries = () => {
-  const focusedDirent = getFocusedDirent()
-  if (!focusedDirent) {
-    return ALL_ENTRIES
-  }
-  switch (focusedDirent.type) {
-    case DirentType.Directory:
-      return getMenuEntriesDirectory()
-    case DirentType.File:
-      return getMenuEntriesFile()
-    default:
-      return getMenuEntriesDefault()
-  }
-}

package/static/3d96d42/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesFile.js

@@ -1,65 +0,0 @@
-import * as I18nString from '../I18NString/I18NString.js'
-import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
-
-export const UiStrings = {
-  NewFile: 'New File',
-  NewWindow: 'New Window',
-  Separator: 'Separator',
-  OpenFile: 'Open File',
-  OpenFolder: 'Open Folder',
-  OpenRecent: 'Open Recent',
-  Exit: 'Exit',
-}
-
-export const getMenuEntries = () => {
-  return [
-    {
-      id: 'newFile',
-      label: I18nString.i18nString(UiStrings.NewFile),
-      flags: MenuItemFlags.None,
-      command: -1,
-    },
-    {
-      id: 'newWindow',
-      label: I18nString.i18nString(UiStrings.NewWindow),
-      flags: MenuItemFlags.None,
-      command: /* Window.openNew */ 'Window.openNew',
-    },
-    {
-      id: 'separator',
-      label: I18nString.i18nString(UiStrings.Separator),
-      flags: MenuItemFlags.Separator,
-      command: MenuItemFlags.None,
-    },
-    {
-      id: 'openFile',
-      label: I18nString.i18nString(UiStrings.OpenFile),
-      flags: MenuItemFlags.None,
-      command: 'Dialog.openFile',
-    },
-    {
-      id: 'openFolder',
-      label: I18nString.i18nString(UiStrings.OpenFolder),
-      flags: MenuItemFlags.None,
-      command: 'Dialog.openFolder',
-    },
-    {
-      id: 'openRecent',
-      label: I18nString.i18nString(UiStrings.OpenRecent),
-      flags: MenuItemFlags.SubMenu,
-      command: MenuItemFlags.None,
-    },
-    {
-      id: 'separator',
-      label: I18nString.i18nString(UiStrings.Separator),
-      flags: MenuItemFlags.Separator,
-      command: MenuItemFlags.None,
-    },
-    {
-      id: 'exit',
-      label: I18nString.i18nString(UiStrings.Exit),
-      flags: MenuItemFlags.None,
-      command: /* Window.exit */ 'Window.exit',
-    },
-  ]
-}