@lvce-editor/server 0.0.39 → 0.1.0

package/static/1a57391/packages/renderer-worker/src/parts/Languages/Languages.js

@@ -0,0 +1,165 @@
+// TODO merge all of this with extension host languages module
+
+import * as Assert from '../Assert/Assert.js'
+import * as ExtensionHostLanguages from '../ExtensionHost/ExtensionHostLanguages.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+
+export const state = {
+  loadState: false,
+  isHydrating: false,
+  fileNameMap: Object.create(null),
+  extensionMap: Object.create(null),
+  tokenizerMap: Object.create(null),
+}
+
+export const getLanguageId = (fileName) => {
+  Assert.string(fileName)
+  // TODO this is inefficient for icon theme, as file extension is computed twice
+  const extension = fileName.slice(fileName.lastIndexOf('.'))
+  const fileNameLower = fileName.toLowerCase()
+  const { extensionMap, fileNameMap } = state
+  if (extensionMap[extension]) {
+    return extensionMap[extension]
+  }
+  if (fileNameMap[fileNameLower]) {
+    return fileNameMap[fileNameLower]
+  }
+  return 'unknown'
+}
+
+export const getTokenizeFunctionPath = (languageId) => {
+  // TODO what if language.tokenize is not of type string? -> handle error gracefully
+  return state.tokenizerMap[languageId] || ''
+}
+
+const getLanguages = () => {
+  // TODO handle error
+
+  return ExtensionHostLanguages.getLanguages()
+}
+
+export const hydrate = async () => {
+  state.isHydrating = true
+  // TODO handle error
+  // TODO main parts should have nothing todo with shared process -> only sub components
+  const languages = await getLanguages()
+  // TODO avoid side effect here, but how?
+  await addLanguages(languages)
+  state.loaded = true
+}
+
+// TODO make contribution points not rely on globals and side effects
+const contributionPointFileExtensions = {
+  key: 'fileExtensions',
+  handle(value, languageId) {
+    if (value) {
+      console.warn(
+        `[renderer-worker] unsupported property "fileExtensions" for language ${language.id}, use the property "extensions" instead`
+      )
+    }
+  },
+}
+
+const contributionPointFileNames = {
+  key: 'fileNames',
+  handle(value, languageId) {
+    if (value && Array.isArray(value)) {
+      for (const fileName of value) {
+        if (typeof fileName === 'string') {
+          const fileNameLower = fileName.toLowerCase()
+          state.fileNameMap[fileNameLower] = languageId
+        } else {
+          console.warn(
+            `[renderer-worker] language.fileNames for ${languageId} should be an array of strings but includes ${typeof fileName}`
+          )
+        }
+      }
+      state.fileNameMap
+    }
+  },
+}
+
+const contributionPointExtensions = {
+  key: 'extensions',
+  handle(value, languageId) {
+    if (value && Array.isArray(value)) {
+      for (const extension of value) {
+        if (typeof extension === 'string') {
+          state.extensionMap[extension] = languageId
+        } else {
+          console.warn(
+            `[renderer-worker] language.extensions for ${languageId} should be an array of strings but includes ${typeof extension}`
+          )
+        }
+      }
+    }
+  },
+}
+
+const contributionPointTokenize = {
+  key: 'tokenize',
+  handle(value, languageId) {
+    if (value) {
+      state.tokenizerMap[languageId] = value
+    }
+  },
+}
+
+const contributionPoints = [
+  contributionPointFileExtensions,
+  contributionPointExtensions,
+  contributionPointFileNames,
+  contributionPointTokenize,
+]
+
+const addLanguage = (language) => {
+  const languageId = language.id
+  if (!languageId) {
+    console.warn(`[renderer-worker] language is missing id`, language)
+    return
+  }
+  // TODO could use object destructuing here
+  for (const contributionPoint of contributionPoints) {
+    const value = language[contributionPoint.key]
+    contributionPoint.handle(value, languageId)
+  }
+}
+
+export const addLanguages = async (languages) => {
+  for (const language of languages) {
+    addLanguage(language)
+  }
+  await GlobalEventBus.emitEvent('languages.changed')
+}
+
+export const hasLoaded = () => {
+  return state.loaded
+}
+
+export const waitForLoad = async () => {
+  if (state.isHydrating) {
+    await new Promise((resolve) => {
+      const handleLanguageChange = (editor, languageId) => {
+        resolve(undefined)
+      }
+      // TODO remove event listener when promise is resolved
+      // TODO what if this event is never emitted (e.g. languages fail to load)
+      GlobalEventBus.addListener('languages.changed', handleLanguageChange)
+    })
+  } else {
+    await hydrate()
+  }
+}
+
+export const getLanguageConfiguration = async (editor) => {
+  if (!hasLoaded()) {
+    throw new Error(
+      'languages must be loaded before requesting language configuration'
+    )
+  }
+  editor.languageId = getLanguageId(editor.uri)
+  const languageConfiguration = ExtensionHostLanguages.getLanguageConfiguration(
+    editor.languageId
+  )
+  return languageConfiguration
+}

package/static/1a57391/packages/renderer-worker/src/parts/LocalStorage/LocalStorage.js

@@ -0,0 +1,22 @@
+import * as WebStorage from '../WebStorage/WebStorage.js'
+import * as WebStorageType from '../WebStorageType/WebStorageType.js'
+
+export const clear = () => {
+  return WebStorage.clear(WebStorageType.LocalStorage)
+}
+
+export const getText = (key) => {
+  return WebStorage.getText(WebStorageType.LocalStorage, key)
+}
+
+export const getJson = (key) => {
+  return WebStorage.getJson(WebStorageType.LocalStorage, key)
+}
+
+export const setText = (key, value) => {
+  return WebStorage.setText(WebStorageType.LocalStorage, key, value)
+}
+
+export const setJson = (key, value) => {
+  return WebStorage.setJson(WebStorageType.LocalStorage, key, value)
+}

package/static/{7fcf005 → 1a57391}/packages/renderer-worker/src/parts/Menu/Menu.ipc.js

@@ -1,14 +1,15 @@
 import * as Menu from './Menu.js'
 
 export const Commands = {
-  'Menu.show': Menu.show,
-  'Menu.hide': Menu.hide,
-  'Menu.selectIndex': Menu.selectIndex,
-  'Menu.focusNext': Menu.focusNext,
-  'Menu.focusPrevious': Menu.focusPrevious,
   'Menu.focusFirst': Menu.focusFirst,
-  'Menu.focusLast': Menu.focusLast,
   'Menu.focusIndex': Menu.focusIndex,
+  'Menu.focusLast': Menu.focusLast,
+  'Menu.focusNext': Menu.focusNext,
+  'Menu.focusPrevious': Menu.focusPrevious,
   'Menu.handleMouseEnter': Menu.handleMouseEnter,
+  'Menu.handleMouseLeave': Menu.handleMouseLeave,
+  'Menu.hide': Menu.hide,
+  'Menu.selectIndex': Menu.selectIndex,
   'Menu.selectItem': Menu.selectItem,
+  'Menu.show': Menu.show,
 }

package/static/{7fcf005 → 1a57391}/packages/renderer-worker/src/parts/Menu/Menu.js

@@ -3,6 +3,7 @@ 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'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
 
 export const state = {
   /**
@@ -259,6 +260,21 @@ export const handleMouseEnter = async (
   }
 }
 
+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
@@ -332,7 +348,13 @@ export const focusPrevious = async () => {
 }
 
 const canBeFocused = (item) => {
-  return item.flags !== /* Separator */ 1 && item.flags !== /* Disabled */ 5
+  switch (item.flags) {
+    case MenuItemFlags.Separator:
+    case MenuItemFlags.Disabled:
+      return false
+    default:
+      return true
+  }
 }
 
 const getIndexToFocusNext = (menu) => {

package/static/{7fcf005 → 1a57391}/packages/renderer-worker/src/parts/MenuCore/MenuCore.js

@@ -1,3 +1,5 @@
+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
@@ -38,7 +40,10 @@ export const getIndexToFocusPrevious = (menu) => {
 }
 
 const canBeFocused = (item) => {
-  return item.flags !== /* Separator */ 1 && item.flags !== /* Disabled */ 5
+  return (
+    item.flags !== MenuItemFlags.Separator &&
+    item.flags !== MenuItemFlags.Disabled
+  )
 }
 
 export const getIndexToFocusNext = (menu) => {

package/static/1a57391/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesActivityBar.js

@@ -0,0 +1,44 @@
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as I18nString from '../I18NString/I18NString.js'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
+
+export const UiStrings = {
+  Seperator: 'Separator',
+  MoveSideBarLeft: 'Move Side Bar Left',
+  HideActivityBar: 'Hide Activity Bar',
+}
+
+const toContextMenuItem = (activityBarItem) => {
+  return {
+    label: activityBarItem.id,
+    id: 8000, // TODO
+    flags: activityBarItem.enabled
+      ? MenuItemFlags.Checked
+      : MenuItemFlags.Unchecked,
+  }
+}
+
+export const getMenuEntries = async () => {
+  const activityBarItems =
+    ViewletStates.getState('ActivityBar').activityBarItems
+  return [
+    ...activityBarItems.map(toContextMenuItem),
+    {
+      id: 'separator',
+      label: I18nString.i18nString(UiStrings.Seperator),
+      flags: MenuItemFlags.Separator,
+    },
+    {
+      id: 'moveSideBarLeft',
+      label: I18nString.i18nString(UiStrings.MoveSideBarLeft), // TODO should be dynamic
+      flags: MenuItemFlags.None,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'hideActivityBar',
+      label: I18nString.i18nString(UiStrings.HideActivityBar),
+      flags: MenuItemFlags.None,
+      command: /* Layout.hideActivityBar */ 'Layout.hideActivityBar',
+    },
+  ]
+}

package/static/{7fcf005 → 1a57391}/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesActivityBarAdditionalViews.js

@@ -1,10 +1,11 @@
 import * as Command from '../Command/Command.js'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
 
 const toContextMenuItem = (activityBarItem) => {
   return {
     label: activityBarItem.id,
     id: 8000, // TODO
-    flags: /* None */ 0,
+    flags: MenuItemFlags.None,
     command: -1,
   }
 }

package/static/1a57391/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesEdit.js

@@ -0,0 +1,72 @@
+import * as I18nString from '../I18NString/I18NString.js'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
+
+export const UiStrings = {
+  Undo: 'Undo',
+  Redo: 'Redo',
+  Separator: 'Separator',
+  Cut: 'Cut',
+  Copy: 'Copy',
+  Paste: 'Paste',
+  ToggleLineComment: 'Toggle Line Comment',
+  ToggleBlockComment: 'Toggle Block Comment',
+}
+
+export const getMenuEntries = () => {
+  return [
+    {
+      id: 'undo',
+      label: I18nString.i18nString(UiStrings.Undo),
+      flags: MenuItemFlags.Disabled,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'redo',
+      label: I18nString.i18nString(UiStrings.Redo),
+      flags: MenuItemFlags.Disabled,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'separator',
+      label: I18nString.i18nString(UiStrings.Separator),
+      flags: MenuItemFlags.Separator,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'cut',
+      label: I18nString.i18nString(UiStrings.Cut),
+      flags: MenuItemFlags.None,
+      command: /* Editor.cut */ 'Editor.cut',
+    },
+    {
+      id: 'copy',
+      label: I18nString.i18nString(UiStrings.Copy),
+      flags: MenuItemFlags.None,
+      command: /* Editor.copy */ 'Editor.copy',
+    },
+    {
+      id: 'paste',
+      label: I18nString.i18nString(UiStrings.Paste),
+      flags: MenuItemFlags.None,
+      command: /* Editor.paste */ 'Editor.paste',
+    },
+    {
+      id: 'separator',
+      label: I18nString.i18nString(UiStrings.Separator),
+      flags: MenuItemFlags.None,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'toggle-line-comment',
+      label: I18nString.i18nString(UiStrings.ToggleLineComment),
+      flags: MenuItemFlags.None,
+      command: /* Editor.toggleLineComment */ 'Editor.toggleLineComment',
+    },
+    {
+      id: 'toggle-block-comment',
+      label: I18nString.i18nString(UiStrings.ToggleBlockComment),
+      flags: MenuItemFlags.None,
+      command: /* Editor.toggleBlockComment */ 'Editor.toggleBlockComment',
+    },
+  ]
+}

package/static/1a57391/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesEditor.js

@@ -0,0 +1,54 @@
+import * as I18nString from '../I18NString/I18NString.js'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
+
+export const UiStrings = {
+  GoToTypeDefinition: 'Go To Type Definition',
+  FindAllReferences: 'Find All References',
+  FindAllImplementations: 'Find All Implementations',
+  Cut: 'Cut',
+  Copy: 'Copy',
+  Paste: 'Paste',
+}
+
+export const getMenuEntries = () => {
+  return [
+    {
+      id: 'go-to-type-definition',
+      label: I18nString.i18nString(UiStrings.GoToTypeDefinition),
+      flags: MenuItemFlags.None,
+      command: /* Editor.goToTypeDefinition */ 'Editor.goToTypeDefinition',
+    },
+    {
+      id: 'find-all-references',
+      label: I18nString.i18nString(UiStrings.FindAllReferences),
+      flags: MenuItemFlags.None,
+      command: /* ViewletSideBar.show */ 'SideBar.show',
+      args: [/* id */ 'References', /* focus */ true],
+    },
+    {
+      id: 'find-all-implementations',
+      label: I18nString.i18nString(UiStrings.FindAllImplementations),
+      flags: MenuItemFlags.None,
+      command: /* ViewletSideBar.show */ 'SideBar.show',
+      args: [/* id */ 'Implementations', /* focus */ true],
+    },
+    {
+      id: 'cut',
+      label: I18nString.i18nString(UiStrings.Cut),
+      flags: MenuItemFlags.None,
+      command: /* Editor.cut */ 'Editor.cut',
+    },
+    {
+      id: 'copy',
+      label: I18nString.i18nString(UiStrings.Copy),
+      flags: MenuItemFlags.None,
+      command: /* Editor.copy */ 'Editor.copy',
+    },
+    {
+      id: 'paste',
+      label: I18nString.i18nString(UiStrings.Paste),
+      flags: MenuItemFlags.None,
+      command: /* Editor.paste */ 'Editor.paste',
+    },
+  ]
+}

package/static/1a57391/packages/renderer-worker/src/parts/MenuEntries/MenuEntriesExplorer.js

@@ -0,0 +1,147 @@
+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.None,
+    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.None,
+    command: /* TODO */ -1,
+  },
+  {
+    id: 'copy',
+    label: I18nString.i18nString(UiStrings.Copy),
+    flags: MenuItemFlags.None,
+    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.None,
+    command: 'Explorer.copyPath',
+  },
+  {
+    id: 'copyRelativePath',
+    label: I18nString.i18nString(UiStrings.CopyRelativePath),
+    flags: MenuItemFlags.None,
+    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()
+  }
+}