@lvce-editor/server 0.4.4 → 0.6.0

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBar.js

@@ -0,0 +1,316 @@
+import * as ActivityBarItemFlags from '../ActivityBarItemFlags/ActvityBarItemFlags.js'
+import * as Command from '../Command/Command.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as I18nString from '../I18NString/I18NString.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  Explorer: 'Explorer',
+  Search: 'Search',
+  SourceControl: 'Source Control',
+  RunAndDebug: 'Run and Debug',
+  Extensions: 'Extensions',
+  Settings: 'Settings',
+  AdditionalViews: 'Additional Views',
+}
+
+export const name = 'ActivityBar'
+
+// TODO rename viewlet parameter to something else (e.g. clicking settings opens context menu not settings viewlet)
+// TODO should just pass index
+// then if item is viewlet -> open viewlet
+// else if item is settings -> open settings
+
+// TODO this should be create
+// TODO unregister listeners when hidden
+
+const getNumberOfVisibleItems = (state) => {
+  const { height, itemHeight } = state
+  const numberOfVisibleItemsTop = Math.floor(height / itemHeight)
+  return numberOfVisibleItemsTop
+}
+
+export const getHiddenItems = (state) => {
+  const numberOfVisibleItems = getNumberOfVisibleItems(state)
+  const items = state.activityBarItems
+  if (numberOfVisibleItems >= items.length) {
+    return []
+  }
+  return state.activityBarItems.slice(numberOfVisibleItems - 2, -1)
+}
+
+const getVisibleActivityBarItems = (state) => {
+  const numberOfVisibleItems = getNumberOfVisibleItems(state)
+  const items = state.activityBarItems
+  if (numberOfVisibleItems >= items.length) {
+    return items
+  }
+  const showMoreItem = {
+    id: 'Additional Views',
+    title: I18nString.i18nString(UiStrings.AdditionalViews),
+    icon: 'icons/ellipsis.svg',
+    enabled: true,
+    flags: ActivityBarItemFlags.Button,
+    keyShortCuts: '',
+  }
+  const visibleItems = [
+    ...items.slice(0, numberOfVisibleItems - 2),
+    showMoreItem,
+    items.at(-1),
+  ]
+  return visibleItems
+}
+
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    // TODO declarative event api is good, but need to bind
+    // listeners to state somehow
+    // also the use of global event bus is not good
+    // and this api is not strongly typed
+    events: {
+      'SourceControl.changeBadgeCount': 8012,
+      'Layout.hideSideBar': 8014,
+      'SideBar.viewletChange': 8013,
+    },
+    activityBarItems: [],
+    focusedIndex: -1,
+    selectedIndex: -1,
+    left,
+    top,
+    width,
+    height,
+    itemHeight: 48,
+  }
+}
+
+const getActivityBarItems = () => {
+  return [
+    // Top
+    {
+      id: 'Explorer',
+      title: I18nString.i18nString(UiStrings.Explorer),
+      icon: 'icons/files.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Tab,
+      keyShortcuts: 'Control+Shift+E',
+    },
+    {
+      id: 'Search',
+      title: I18nString.i18nString(UiStrings.Search),
+      icon: 'icons/search.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Tab,
+      keyShortcuts: 'Control+Shift+F',
+    },
+    {
+      id: 'Source Control',
+      title: I18nString.i18nString(UiStrings.SourceControl),
+      icon: 'icons/source-control.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Tab,
+      keyShortcuts: 'Control+Shift+G',
+    },
+    {
+      id: 'Run and Debug',
+      title: I18nString.i18nString(UiStrings.RunAndDebug),
+      icon: 'icons/debug-alt-2.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Tab,
+      keyShortcuts: 'Control+Shift+D',
+    },
+    {
+      id: 'Extensions',
+      title: I18nString.i18nString(UiStrings.Extensions),
+      icon: 'icons/extensions.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Tab,
+      keyShortcuts: 'Control+Shift+X',
+    },
+    // Bottom
+    {
+      id: 'Settings',
+      title: I18nString.i18nString(UiStrings.Settings),
+      icon: 'icons/settings-gear.svg',
+      enabled: true,
+      flags: ActivityBarItemFlags.Button,
+      keyShortcuts: '',
+    },
+  ]
+}
+
+export const loadContent = async (state) => {
+  const activityBarItems = getActivityBarItems()
+  const sideBar = ViewletStates.getInstance('SideBar')
+  const viewletId =
+    sideBar && sideBar.state ? sideBar.state.currentViewletId : ''
+  const selectedIndex = findIndex(activityBarItems, viewletId)
+  return {
+    ...state,
+    selectedIndex,
+    activityBarItems,
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const contentLoadedEffects = (state) => {
+  // TODO
+  GlobalEventBus.addListener(
+    'SourceControl.changeBadgeCount',
+    updateSourceControlCount
+  )
+  GlobalEventBus.addListener('Layout.hideSideBar', handleSideBarHidden)
+  GlobalEventBus.addListener('SideBar.viewletChange', (id) =>
+    handleSideBarViewletChange(state, id)
+  )
+}
+
+export const dispose = () => {
+  GlobalEventBus.removeListener(
+    'SourceControl.changeBadgeCount',
+    updateSourceControlCount
+  )
+  GlobalEventBus.removeListener('Layout.hideSideBar', handleSideBarHidden)
+  GlobalEventBus.removeListener(
+    'SideBar.viewletChange',
+    handleSideBarViewletChange
+  )
+}
+
+const findIndex = (activityBarItems, id) => {
+  for (let i = 0; i < activityBarItems.length; i++) {
+    if (activityBarItems[i].id === id) {
+      return i
+    }
+  }
+  return -1
+}
+
+export const handleSideBarViewletChange = async (state, id, ...args) => {
+  const index = findIndex(state.activityBarItems, id)
+  const oldIndex = state.selectedIndex
+  state.selectedIndex = index
+  await RendererProcess.invoke(
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'ActivityBar',
+    /* method */ 'selectIndex',
+    /* oldIndex */ oldIndex,
+    /* newIndex */ index
+  )
+}
+
+export const handleSideBarHidden = async (state) => {
+  const oldIndex = state.focusedIndex
+  state.focusedIndex = -1
+  await RendererProcess.invoke(
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'ActivityBar',
+    /* method */ 'selectIndex',
+    /* oldIndex */ oldIndex,
+    /* newIndex */ -1
+  )
+}
+
+export const updateSourceControlCount = async (state, count) => {
+  if (count === 0) {
+    return
+  }
+  const index = state.activityBarItems.findIndex(
+    (item) => item.id === 'Source Control'
+  )
+  if (index === -1) {
+    return
+  }
+  await RendererProcess.invoke(
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'ActivityBar',
+    /* method */ 'setBadgeCount',
+    /* index */ index,
+    /* count */ count
+  )
+
+  // TODO send count to renderer process (if activity bar is visible)
+}
+
+export const toggleItem = (context, item) => {
+  // const item = activityBarFindItem(id)
+}
+
+const isEnabled = (activityBarItem) => {
+  return activityBarItem.enabled
+}
+
+export const toggleActivityBarItem = async (state, item) => {
+  const activityBarItem = state.activityBarItems.find(
+    (activityBarItem) => activityBarItem.id === item.label
+  )
+  activityBarItem.enabled = !activityBarItem.enabled
+  await RendererProcess.invoke(
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'ActivityBar',
+    /* method */ 'setItems',
+    /* items */ state.activityBarItems.filter(isEnabled),
+    /* index */ state.selectedIndex
+  )
+}
+
+export const handleContextMenu = async (state, x, y) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ MenuEntryId.ActivityBar
+  )
+  return state
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return {
+    ...state,
+    ...dimensions,
+  }
+}
+
+const renderActivityBarItems = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.activityBarItems === newState.activityBarItems &&
+      oldState.height === newState.height
+    )
+  },
+  apply(oldState, newState) {
+    const visibleItems = getVisibleActivityBarItems(newState)
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'ActivityBar',
+      /* method */ 'setItems',
+      /* items */ visibleItems,
+    ]
+  },
+}
+
+const renderFocusedIndex = {
+  isEqual(oldState, newState) {
+    return oldState.focusedIndex === newState.focusedIndex
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'ActivityBar',
+      /* method */ 'setFocusedIndex',
+      /* unFocusIndex */ oldState.focusedIndex,
+      /* focusIndex */ newState.focusedIndex,
+    ]
+  },
+}
+
+export const render = [renderActivityBarItems, renderFocusedIndex]
+
+export const hasFunctionalRender = true

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarFocusLast.js

@@ -0,0 +1,6 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+import * as Arrays from '../Arrays/Arrays.js'
+
+export const focusLast = (state) => {
+  return focusIndex(state, Arrays.lastIndex(state.activityBarItems))
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarHandleClick.js

@@ -0,0 +1,48 @@
+import * as Command from '../Command/Command.js'
+import * as Layout from '../Layout/Layout.js'
+import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
+
+const handleClickSettings = async (state, x, y, viewletId) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ MenuEntryId.Settings
+  )
+  return state
+}
+
+const handleClickAdditionalViews = async (state, x, y, viewletId) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ MenuEntryId.ActivityBarAdditionalViews
+  )
+  return state
+}
+
+const handleClickOther = async (state, x, y, viewletId) => {
+  if (Layout.isSideBarVisible()) {
+    await Command.execute(
+      /* SideBar.showOrHideViewlet */ 'SideBar.showOrHideViewlet',
+      /* id */ viewletId
+    )
+  } else {
+    // TODO should show side bar with viewletId
+    await Layout.showSideBar()
+  }
+  return state
+}
+
+export const handleClick = async (state, index, x, y) => {
+  const viewletId = state.activityBarItems[index].id
+  switch (viewletId) {
+    case 'Settings':
+      return handleClickSettings(state, x, y, viewletId)
+    case 'Additional Views':
+      return handleClickAdditionalViews(state, x, y, viewletId)
+    default:
+      return handleClickOther(state, x, y, viewletId)
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBarSelectCurrent.js

@@ -0,0 +1,25 @@
+import { handleClick } from './ViewletActivityBarHandleClick.js'
+
+const getPosition = (state, index) => {
+  const { activityBarItems, top, left, height, itemHeight } = state
+  if (index > activityBarItems.length - 2) {
+    // at bottom
+    return {
+      x: left,
+      y: top + height - (activityBarItems.length - 1 - index) * itemHeight,
+    }
+  }
+  // at top
+  return {
+    x: left,
+    y: top + index * itemHeight,
+  }
+}
+
+export const selectCurrent = (state) => {
+  if (state.focusedIndex === -1) {
+    return
+  }
+  const position = getPosition(state, state.focusedIndex)
+  return handleClick(state, state.focusedIndex, position.x, position.y)
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorCompletion/ViewletEditorCompletion.js

@@ -0,0 +1,237 @@
+import * as Command from '../Command/Command.js'
+import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
+import * as EditorShowMessage from '../EditorCommand/EditorCommandShowMessage.js'
+import * as EditorCompletionMap from '../EditorCompletionMap/EditorCompletionMap.js'
+import * as ExtensionHostCompletion from '../ExtensionHost/ExtensionHostCompletion.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+export const create = (id, uri, top, left, width, height) => {
+  console.log({ id, uri, top, left, width, height })
+  return {
+    completionItems: [],
+    focusedIndex: 0,
+    isOpened: false,
+    openingReason: 0,
+    editor: undefined,
+    abortController: new AbortController(),
+    rowIndex: 0,
+    columnIndex: 0,
+    leadingWord: '',
+    loadingTimeout: -1,
+    filteredCompletionItems: [],
+    visibleItems: [],
+    x: 0,
+    y: 0,
+  }
+}
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+const getCompletions = async (editor) => {
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  // Editor.sync(editor)
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  const completions = await ExtensionHostCompletion.executeCompletionProvider(
+    editor,
+    offset
+  )
+  return completions
+}
+
+const filterCompletionItems = (completionItems, word) => {
+  const includesWord = (completionItem) => {
+    return completionItem.label.includes(word)
+  }
+  const filteredCompletions = completionItems.filter(includesWord)
+  return filteredCompletions
+}
+
+const getEditor = () => {
+  return Viewlet.getState('EditorText')
+}
+
+const getLabel = (item) => {
+  return item.label
+}
+
+const getVisibleItems = (filteredItems) => {
+  const visibleItems = []
+  for (const filteredItem of filteredItems) {
+    visibleItems.push({
+      label: getLabel(filteredItem),
+      icon: EditorCompletionMap.getIconClassName(filteredItem),
+    })
+  }
+  return visibleItems
+  // for(const )
+}
+
+const getDisplayErrorMessage = (error) => {
+  const message = `${error}`
+  const errorPrefix = 'Error: '
+  if (message.startsWith(errorPrefix)) {
+    return message.slice(errorPrefix.length)
+  }
+  return message
+}
+
+export const loadContent = async (state) => {
+  const editor = getEditor()
+  const completionItems = await getCompletions(editor)
+  const filteredCompletionItems = filterCompletionItems(completionItems, '')
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const x = EditorPosition.x(editor, rowIndex, columnIndex)
+  const y = EditorPosition.y(editor, rowIndex, columnIndex)
+  const visibleItems = getVisibleItems(filteredCompletionItems)
+  console.log({ completionItems, filteredCompletionItems, visibleItems })
+  return {
+    ...state,
+    completionItems,
+    filteredCompletionItems,
+    visibleItems,
+    x,
+    y,
+  }
+}
+
+export const handleError = async (error) => {
+  const displayErrorMessage = getDisplayErrorMessage(error)
+  const editor = getEditor()
+  await EditorShowMessage.editorShowMessage(
+    /* editor */ editor,
+    /* rowIndex */ 0,
+    /* columnIndex */ 0,
+    /* message */ displayErrorMessage,
+    /* isError */ true
+  )
+}
+
+export const loadingContent = () => {
+  const editor = getEditor()
+  console.log('show loading')
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const x = EditorPosition.x(editor, rowIndex, columnIndex)
+  const y = EditorPosition.y(editor, rowIndex, columnIndex)
+  const changes = [
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorCompletion',
+    /* method */ 'showLoading',
+    /* x */ x,
+    /* y */ y,
+  ]
+  return changes
+}
+
+export const contentLoaded = () => {
+  // noop
+}
+
+export const handleSelectionChange = (state, selectionChanges) => {}
+
+export const advance = (state, word) => {
+  const filteredCompletionItems = filterCompletionItems(
+    state.completionItems,
+    word
+  )
+  return {
+    ...state,
+    filteredCompletionItems,
+  }
+}
+
+const getInsertSnippet = (word, leadingWord) => {
+  if (word.startsWith(leadingWord)) {
+    return word.slice(leadingWord.length)
+  }
+  return word
+}
+
+const select = async (state, completionItem) => {
+  const { leadingWord } = state
+  const word = completionItem.label
+  const snippet = getInsertSnippet(word, leadingWord)
+  // TODO type and dispose commands should be sent to renderer process at the same time
+  await Command.execute(/* Editor.type */ 'Editor.type', /* text */ snippet)
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const selectIndex = (state, index) => {
+  const completionItem = state.filteredCompletionItems[index]
+  return select(state, completionItem)
+}
+
+export const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+export const focusFirst = (state) => {
+  return focusIndex(state, 0)
+}
+
+export const focusLast = (state) => {
+  return focusIndex(state, state.completionItems.length - 1)
+}
+
+export const focusPrevious = (state) => {
+  if (state.focusedIndex === 0) {
+    return focusLast(state)
+  }
+  return focusIndex(state, state.focusedIndex - 1)
+}
+
+export const focusNext = (state) => {
+  if (state.focusedIndex === state.completionItems.length - 1) {
+    return focusFirst(state)
+  }
+  return focusIndex(state, state.focusedIndex + 1)
+}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderPosition = {
+  isEqual(oldState, newState) {
+    return oldState.x === newState.x && oldState.y === newState.y
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorCompletion',
+      /* method */ 'setPosition',
+      /* x */ newState.x,
+      /* y */ newState.y,
+    ]
+  },
+}
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.visibleItems === newState.visibleItems
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'EditorCompletion',
+      /* method */ 'setItems',
+      /* items */ newState.visibleItems,
+      /* reason */ 1,
+    ]
+  },
+}
+
+export const render = [renderItems, renderPosition]

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletEditorFindWidget/ViewletEditorFindWidget.ipc.js

@@ -0,0 +1,11 @@
+import * as ViewletEditorFindWidget from './ViewletEditorFindWidget.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'EditorFindWidget.handleInput': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.handleInput),
+  'EditorFindWidget.focusNext': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.focusNext),
+  'EditorFindWidget.focusPrevious': Viewlet.wrapViewletCommand('EditorFindWidget', ViewletEditorFindWidget.focusPrevious),
+}
+
+export * from './ViewletEditorFindWidget.js'