@lvce-editor/server 0.0.2

package/static/1914fad/packages/renderer-worker/src/parts/Menu/Menu.js

@@ -0,0 +1,343 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Command from '../Command/Command.js'
+// TODO lazyload menuEntries and use Command.execute (maybe)
+import * as MenuEntries from '../MenuEntries/MenuEntries.js'
+import * as Layout from '../Layout/Layout.js'
+
+export const state = {
+  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 */ 7905,
+    /* 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.send([
+    /* 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.send([
+    /* Menu.showMenu */ 7905,
+    /* 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)
+}
+
+export const selectIndex = async (level, index) => {
+  const menu = state.menus[level]
+  menu.focusedIndex = index
+  const item = menu.items[menu.focusedIndex]
+  switch (item.flags) {
+    case /* None */ 0:
+      if (!item.command) {
+        console.warn('item has missing command', item)
+        return
+      }
+      const args = item.args || []
+      await Promise.all([hide(), Command.execute(item.command, ...args)])
+      break
+    case /* SubMenu */ 4:
+      if (menu.focusedIndex === index) {
+        return
+      }
+      await showSubMenu(menu.level, menu.focusedIndex)
+      break
+    default:
+      break
+  }
+}
+
+export const selectCurrent = async (level) => {
+  const menu = state.menus[level]
+  await selectIndex(level, menu.focusedIndex)
+}
+
+export const hide = async () => {
+  if (state.menus.length === 0) {
+    return
+  }
+  state.menus = []
+  await RendererProcess.invoke(/* Menu.hide */ 7901)
+}
+
+// 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 */ 7904,
+      /* 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 focusIndex = async (menu, index) => {
+  if (menu.items.length === 0) {
+    return
+  }
+  const oldFocusedIndex = menu.focusedIndex
+  menu.focusedIndex = index
+  await RendererProcess.invoke(
+    /* Menu.focusIndex */ 7902,
+    /* 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) => {
+  return item.flags !== /* Separator */ 1 && item.flags !== /* Disabled */ 5
+}
+
+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/1914fad/packages/renderer-worker/src/parts/MenuCore/MenuCore.js

@@ -0,0 +1,47 @@
+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 !== /* Separator */ 1 && item.flags !== /* Disabled */ 5
+}
+
+export const getIndexToFocusNext = (menu) => {
+  const startIndex = menu.focusedIndex + 1
+  return getIndexToFocusNextStartingAt(menu.items, startIndex)
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntries.js

@@ -0,0 +1,45 @@
+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')
+    default:
+      throw new Error(`module not found "${id}"`)
+  }
+}
+
+export const getMenuEntries = async (id) => {
+  const module = await getModule(id)
+  return module.getMenuEntries()
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesActivityBar.js

@@ -0,0 +1,34 @@
+import * as Viewlet from '../Viewlet/Viewlet.js' // TODO dependency to viewlet is not good
+
+const toContextMenuItem = (activityBarItem) => {
+  return {
+    label: activityBarItem.id,
+    id: 8000, // TODO
+    flags: activityBarItem.enabled ? /* Checked */ 2 : /* Unchecked */ 3,
+  }
+}
+
+export const getMenuEntries = async () => {
+  const activityBarItems =
+    Viewlet.state.instances['ActivityBar'].state.activityBarItems
+  return [
+    ...activityBarItems.map(toContextMenuItem),
+    {
+      id: 'separator',
+      label: 'Separator',
+      flags: /* Separator */ 1,
+    },
+    {
+      id: 'moveSideBarLeft',
+      label: 'Move Side Bar Left', // TODO should be dynamic
+      flags: /* None */ 0,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'hideActivityBar',
+      label: 'Hide Activity Bar',
+      flags: /* None */ 0,
+      command: /* Layout.hideActivityBar */ 1107,
+    },
+  ]
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesActivityBarAdditionalViews.js

@@ -0,0 +1,17 @@
+import * as Command from '../Command/Command.js'
+
+const toContextMenuItem = (activityBarItem) => {
+  return {
+    label: activityBarItem.id,
+    id: 8000, // TODO
+    flags: /* None */ 0,
+    command: -1,
+  }
+}
+
+export const getMenuEntries = async () => {
+  const hiddenActivityBarItems = await Command.execute(
+    /* ActivityBar.getHiddenItems */ 8011
+  )
+  return hiddenActivityBarItems.map(toContextMenuItem)
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesEdit.js

@@ -0,0 +1,58 @@
+export const getMenuEntries = () => {
+  return [
+    {
+      id: 'undo',
+      label: 'Undo',
+      flags: /* Disabled */ 5,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'redo',
+      label: 'Redo',
+      flags: /* Disabled */ 5,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'separator',
+      label: '',
+      flags: /* separator */ 1,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'cut',
+      label: 'Cut',
+      flags: /* None */ 0,
+      command: /* EditorCut.editorCut */ 364,
+    },
+    {
+      id: 'copy',
+      label: 'Copy',
+      flags: /* None */ 0,
+      command: /* EditorCopy.editorCopy */ 365,
+    },
+    {
+      id: 'paste',
+      label: 'Paste',
+      flags: /* None */ 0,
+      command: /* EditorPaste.editorPaste */ 383,
+    },
+    {
+      id: 'separator',
+      label: '',
+      flags: /* separator */ 1,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'toggle-line-comment',
+      label: 'Toggle Line Comment',
+      flags: /* None */ 0,
+      command: /* EditorToggleLineComment.editorToggleLineComment */ 373,
+    },
+    {
+      id: 'toggle-block-comment',
+      label: 'Toggle Block Comment',
+      flags: /* None */ 0,
+      command: /* EditorToggleBlockComment.editorToggleBlockComment */ 362,
+    },
+  ]
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesEditor.js

@@ -0,0 +1,42 @@
+export const getMenuEntries = () => {
+  return [
+    {
+      id: 'go-to-type-definition',
+      label: 'Go To Type Definition',
+      flags: /* None */ 0,
+      command: /* EditorCommandGoToTypeDefinition.editorGoToTypeDefinition */ 990,
+    },
+    {
+      id: 'find-all-references',
+      label: 'Find all references',
+      flags: /* None */ 0,
+      command: /* ViewletSideBar.show */ 554,
+      args: [/* id */ 'References', /* focus */ true],
+    },
+    {
+      id: 'find-all-implementations',
+      label: 'Find all implementations',
+      flags: /* None */ 0,
+      command: /* ViewletSideBar.show */ 554,
+      args: [/* id */ 'Implementations', /* focus */ true],
+    },
+    {
+      id: 'cut',
+      label: 'Cut',
+      flags: /* None */ 0,
+      command: /* EditorCut.editorCut */ 364,
+    },
+    {
+      id: 'copy',
+      label: 'Copy',
+      flags: /* None */ 0,
+      command: /* EditorCopy.editorCopy */ 365,
+    },
+    {
+      id: 'paste',
+      label: 'Paste',
+      flags: /* None */ 0,
+      command: /* EditorPaste.editorPaste */ 383,
+    },
+  ]
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesExplorer.js

@@ -0,0 +1,110 @@
+import * as Command from '../Command/Command.js'
+
+const ALL_ENTRIES = [
+  {
+    id: 'newFile',
+    label: 'New File',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.newFile  */ 147,
+  },
+  {
+    id: 'newFolder',
+    label: 'New Folder',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.newFolder */ 152,
+  },
+  {
+    id: 'openContainingFolder',
+    label: 'Open Containing Folder',
+    flags: /* None */ 0,
+    command: /*  ViewletExplorer.openContainingFolder */ 148,
+  },
+  {
+    id: 'openInIntegratedTerminal',
+    label: 'Open in integrated Terminal',
+    flags: /* None */ 0,
+    command: /* TODO */ -1,
+  },
+  {
+    id: '',
+    label: '',
+    flags: /* Separator */ 1,
+    command: /* None */ 0,
+  },
+  {
+    id: 'cut',
+    label: 'Cut',
+    flags: /* None */ 0,
+    command: /* TODO */ -1,
+  },
+  {
+    id: 'copy',
+    label: 'Copy',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.handleCopy */ 166,
+  },
+  {
+    id: 'paste',
+    label: 'Paste',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.handlePaste */ 165,
+  },
+  {
+    id: '',
+    label: '',
+    flags: /* Separator */ 1,
+    command: /* None */ 0,
+  },
+  {
+    id: 'copyPath',
+    label: 'Copy Path',
+    flags: /* None */ 0,
+    command: /* TODO */ -1,
+  },
+  {
+    id: 'copyRelativePath',
+    label: 'Copy Relative Path',
+    flags: /* None */ 0,
+    command: /* TODO */ -1,
+  },
+  {
+    id: '',
+    label: '',
+    flags: /* Separator */ 1,
+    command: /* None */ 0,
+  },
+  {
+    id: 'rename',
+    label: 'Rename',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.renameDirent */ 158,
+  },
+  {
+    id: 'delete',
+    label: 'Delete',
+    flags: /* None */ 0,
+    command: /* ViewletExplorer.removeDirent */ 151,
+  },
+]
+
+const isFileEntry = (entry) => {
+  return entry.id !== 'newFile' && entry.id !== 'newFolder'
+}
+
+export const getMenuEntries = async () => {
+  // TODO explorer might already be disposed (race condition)
+  const focusedDirent = await Command.execute(
+    /* ViewletExplorer.getFocusedDirent */ 153
+  )
+  if (!focusedDirent) {
+    return ALL_ENTRIES
+  }
+  switch (focusedDirent.type) {
+    case 'directory':
+      return ALL_ENTRIES
+    case 'file':
+      return ALL_ENTRIES.filter(isFileEntry)
+    default:
+      return ALL_ENTRIES
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesExplorerFile.js

@@ -0,0 +1,3 @@
+export const getMenuEntries = () => {
+  return []
+}

package/static/1914fad/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesExplorerFolder.js

@@ -0,0 +1,3 @@
+export const getMenuEntries = () => {
+  return []
+}