@lvce-editor/server 0.11.0 → 0.11.2

package/static/2fd2efe/packages/renderer-worker/src/parts/IpcParent/IpcParentWithModuleWorker.js

@@ -1,122 +0,0 @@
-const getDisplayName = (name) => {
-  if (!name) {
-    return '<unknown> worker'
-  }
-  if (name.endsWith('Worker')) {
-    return name.toLowerCase()
-  }
-  return `${name} worker`
-}
-
-const tryToGetActualErrorMessage = async ({ url, name }) => {
-  const displayName = getDisplayName(name)
-  try {
-    await import(url)
-    return `Failed to start ${displayName}: Unknown Error`
-  } catch (error) {
-    if (
-      error &&
-      error instanceof Error &&
-      error.message.startsWith('Failed to fetch dynamically imported module')
-    ) {
-      try {
-        const response = await fetch(url)
-        switch (response.status) {
-          case 404:
-            return `Failed to start ${displayName}: Not found (404)`
-          default:
-            return `Failed to start ${displayName}: Unknown Network Error`
-        }
-      } catch {
-        return `Failed to start ${displayName}: Unknown Network Error`
-      }
-    }
-    return `Failed to start ${displayName}: ${error}`
-  }
-}
-
-const isFirefoxError = (message) => {
-  return [
-    'SyntaxError: import declarations may only appear at top level of a module',
-    'SyntaxError: export declarations may only appear at top level of a module',
-  ].includes(message)
-}
-
-export const create = async ({ url, name }) => {
-  try {
-    const worker = new Worker(url, {
-      type: 'module',
-      name,
-    })
-    await new Promise((resolve, reject) => {
-      const cleanup = () => {
-        worker.onmessage = null
-        worker.onerror = null
-      }
-      const handleFirstMessage = (event) => {
-        cleanup()
-        if (event.data === 'ready') {
-          resolve(undefined)
-        } else {
-          reject(new Error('unexpected first message from worker'))
-        }
-      }
-      const handleFirstError = async (event) => {
-        cleanup()
-        if (isFirefoxError(event.message)) {
-          event.preventDefault()
-          reject(new Error('module workers are not supported in firefox'))
-        } else {
-          const actualErrorMessage = await tryToGetActualErrorMessage({
-            url,
-            name,
-          })
-          reject(new Error(actualErrorMessage))
-        }
-      }
-      worker.onmessage = handleFirstMessage
-      worker.onerror = handleFirstError
-    })
-    let handleMessage
-
-    return {
-      get onmessage() {
-        return handleMessage
-      },
-      set onmessage(listener) {
-        if (listener) {
-          handleMessage = (event) => {
-            // TODO why are some events not instance of message event?
-            if (event instanceof MessageEvent) {
-              const message = event.data
-              listener(message)
-            } else {
-              listener(event)
-            }
-          }
-        } else {
-          handleMessage = null
-        }
-        worker.onmessage = handleMessage
-      },
-      send(message) {
-        worker.postMessage(message)
-      },
-      sendAndTransfer(message, transfer) {
-        worker.postMessage(message, transfer)
-      },
-    }
-  } catch (error) {
-    if (
-      error &&
-      error instanceof Error &&
-      error.message === 'module workers are not supported in firefox'
-    ) {
-      const IpcParentWithMessagePort = await import(
-        './IpcParentWithMessagePort.js'
-      )
-      return IpcParentWithMessagePort.create({ url })
-    }
-    throw error
-  }
-}

package/static/2fd2efe/packages/renderer-worker/src/parts/IpcParent/IpcParentWithWebSocket.js

@@ -1,48 +0,0 @@
-const getWsUrl = () => {
-  const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:'
-
-  return `${wsProtocol}//${location.host}`
-}
-
-export const create = ({ protocol }) => {
-  // TODO replace this during build
-  const wsUrl = getWsUrl()
-  const webSocket = new WebSocket(wsUrl, [protocol])
-  const pendingMessages = []
-  webSocket.onopen = () => {
-    ipc.send = (message) => {
-      const stringifiedMessage = JSON.stringify(message)
-      webSocket.send(stringifiedMessage)
-    }
-    for (const message of pendingMessages) {
-      ipc.send(message)
-    }
-    pendingMessages.length = 0
-  }
-  let handleMessage
-  const ipc = {
-    get onmessage() {
-      return handleMessage
-    },
-    set onmessage(listener) {
-      if (listener) {
-        handleMessage = (event) => {
-          // TODO why are some events not instance of message event?
-          if (event instanceof MessageEvent) {
-            const message = JSON.parse(event.data)
-            listener(message)
-          } else {
-            listener(event)
-          }
-        }
-      } else {
-        handleMessage = null
-      }
-      webSocket.onmessage = handleMessage
-    },
-    send(message) {
-      pendingMessages.push(message)
-    },
-  }
-  return ipc
-}

package/static/2fd2efe/packages/renderer-worker/src/parts/IpcParentType/IpcParentType.js

@@ -1,5 +0,0 @@
-export const Electron = 1
-export const MessagePort = 2
-export const ModuleWorker = 3
-export const ReferencePort = 4
-export const WebSocket = 5

package/static/2fd2efe/packages/renderer-worker/src/parts/Languages/Languages.js

@@ -1,240 +0,0 @@
-// TODO merge all of this with extension host languages module
-
-import * as Assert from '../Assert/Assert.js'
-import * as CodeFrameColumns from '../CodeFrameColumns/CodeFrameColumns.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),
-  /**
-   * @type {any[]}
-   */
-  firstLines: [],
-  /**
-   * @type {string[]}
-   */
-  hasWarned: [],
-}
-
-export const getLanguageId = (fileName) => {
-  Assert.string(fileName)
-  // TODO this is inefficient for icon theme, as file extension is computed twice
-  const extensionIndex = fileName.lastIndexOf('.')
-  const extension = fileName.slice(extensionIndex)
-  const extensionLower = extension.toLowerCase()
-  const { extensionMap, fileNameMap } = state
-  if (extensionMap[extensionLower]) {
-    return extensionMap[extensionLower]
-  }
-  const fileNameLower = fileName.toLowerCase()
-  const secondExtensionIndex = fileName.lastIndexOf('.', extensionIndex - 1)
-  const secondExtension = fileName.slice(secondExtensionIndex)
-  if (secondExtensionIndex !== -1 && extensionMap[secondExtension]) {
-    return extensionMap[secondExtension]
-  }
-  if (fileNameMap[fileNameLower]) {
-    return fileNameMap[fileNameLower]
-  }
-  return 'unknown'
-}
-
-export const getLanguageIdByFirstLine = (firstLine) => {
-  for (const { regex, languageId } of state.firstLines) {
-    const actualRegex = new RegExp(regex)
-    if (actualRegex.test(firstLine)) {
-      return languageId
-    }
-  }
-  return 'unknown'
-}
-
-export const getTokenizeFunctionPath = (languageId) => {
-  // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state.tokenizerMap[languageId] || ''
-}
-
-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 ExtensionHostLanguages.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 ${languageId}, 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 contributionPointFirstLine = {
-  key: 'firstLine',
-  handle(value, languageId) {
-    state.firstLines.push({ regex: value, languageId })
-  },
-}
-
-const warnFileNames = (languageId, language) => {
-  if (state.hasWarned.includes(languageId)) {
-    return
-  }
-  state.hasWarned.push(languageId)
-  const code = JSON.stringify(language, null, 2)
-  const lines = code.split('\n')
-  let rowIndex = 0
-  let columnIndex = 0
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const fileNamesIndex = line.indexOf('filenames')
-    if (fileNamesIndex !== -1) {
-      rowIndex = i
-      columnIndex = fileNamesIndex
-      break
-    }
-  }
-  const codeFrame = CodeFrameColumns.create(code, {
-    start: {
-      line: rowIndex + 1,
-      column: columnIndex + 1,
-    },
-    end: {
-      line: rowIndex + 1,
-      column: columnIndex + 'filenames'.length + 1,
-    },
-  })
-  console.warn(
-    `Please use "fileNames" instead of "filenames" for language ${languageId}
-${codeFrame}
-`
-  )
-}
-
-const contributionPointFileNamesLower = {
-  key: 'filenames',
-  handle(value, languageId, language) {
-    warnFileNames(languageId, language)
-    contributionPointFileNames.handle(value, languageId)
-  },
-}
-
-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,
-  contributionPointFileNamesLower,
-  contributionPointTokenize,
-  contributionPointFirstLine,
-]
-
-export 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
-  // TODO maybe map the other way around from language keys to contribution points
-  for (const contributionPoint of contributionPoints) {
-    const value = language[contributionPoint.key]
-    if (value) {
-      contributionPoint.handle(value, languageId, language)
-    }
-  }
-}
-
-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/2fd2efe/packages/renderer-worker/src/parts/ModuleMap/ModuleMap.js

@@ -1,272 +0,0 @@
-import * as ModuleId from '../ModuleId/ModuleId.js'
-
-export const getModuleId = (commandId) => {
-  switch (commandId) {
-    // TODO this should be in layout module
-    case 'Ajax.getBlob':
-    case 'Ajax.getJson':
-    case 'Ajax.getText':
-      return ModuleId.Ajax
-    case 'Audio.playBell':
-      return ModuleId.Audio
-    case 'Base64.decode':
-    case 'Base64.encode':
-      return ModuleId.Base64
-    case 'Blob.base64StringToBlob':
-    case 'Blob.binaryStringToBlob':
-    case 'Blob.blobToBinaryString':
-      return ModuleId.Blob
-    case 'CacheStorage.clearCache':
-    case 'CacheStorage.getJson':
-    case 'CacheStorage.setJson':
-      return ModuleId.CacheStorage
-    case 'Callback.reject':
-    case 'Callback.resolve':
-      return ModuleId.Callback
-    case 'Chrome.close':
-    case 'Chrome.exit':
-    case 'Chrome.maximize':
-    case 'Chrome.minimize':
-    case 'Chrome.unmaximize':
-      return ModuleId.Chrome
-    case 'ChromeExtension.install':
-    case 'ChromeExtension.uninstall':
-      return ModuleId.ChromeExtension
-    case 'ClipBoard.execCopy':
-    case 'ClipBoard.readNativeFiles':
-    case 'ClipBoard.readText':
-    case 'ClipBoard.writeImage':
-    case 'ClipBoard.writeNativeFiles':
-    case 'ClipBoard.writeText':
-      return ModuleId.ClipBoard
-    case 'ColorPicker.close':
-    case 'ColorPicker.open':
-      return ModuleId.ColorPicker
-    case 'ColorTheme.hydrate':
-    case 'ColorTheme.reload':
-    case 'ColorTheme.setColorTheme':
-      return ModuleId.ColorTheme
-    case 'ColorThemeFromJson.createColorThemeFromJson':
-      return ModuleId.ColorThemeFromJson
-    case 'ContentTracing.start':
-    case 'ContentTracing.stop':
-      return ModuleId.ContentTracing
-    case 'ContextMenu.focusFirst':
-    case 'ContextMenu.focusLast':
-    case 'ContextMenu.focusNext':
-    case 'ContextMenu.focusPrevious':
-    case 'ContextMenu.hide':
-    case 'ContextMenu.select':
-    case 'ContextMenu.selectCurrent':
-    case 'ContextMenu.show':
-      return ModuleId.ContextMenu
-    case 'Developer.allocateMemoryInSharedProcess':
-    case 'Developer.clearCache':
-    case 'Developer.crashMainProcess':
-    case 'Developer.crashSharedProcess':
-    case 'Developer.createSharedProcessHeapSnapshot':
-    case 'Developer.createSharedProcessProfile':
-    case 'Developer.downloadViewletState':
-    case 'Developer.getMemoryUsageContent':
-    case 'Developer.getStartupPerformanceContent':
-    case 'Developer.installChromeExtensionIStillDontCareAboutCookies':
-    case 'Developer.installChromeExtensionUBlockOrigin':
-    case 'Developer.openCacheFolder':
-    case 'Developer.openConfigFolder':
-    case 'Developer.openDataFolder':
-    case 'Developer.openLogsFolder':
-    case 'Developer.openProcessExplorer':
-    case 'Developer.reloadColorTheme':
-    case 'Developer.reloadIconTheme':
-    case 'Developer.showColorThemeCss':
-    case 'Developer.showIconThemeCss':
-    case 'Developer.showMemoryUsage':
-    case 'Developer.showStartupPerformance':
-    case 'Developer.startupPerformance':
-    case 'Developer.toggleDeveloperTools':
-      return ModuleId.Developer
-    case 'Dialog.close':
-    case 'Dialog.handleClick':
-    case 'Dialog.openFile':
-    case 'Dialog.openFolder':
-    case 'Dialog.showAbout':
-    case 'Dialog.showMessage':
-      return ModuleId.Dialog
-    case 'Download.downloadFile':
-    case 'Download.downloadJson':
-    case 'Download.downloadToDownloadsFolder':
-      return ModuleId.Download
-    case 'EditorDiagnostics.hydrate':
-      return ModuleId.EditorDiagnostics
-    case 3900:
-      return ModuleId.EditorError
-    case 'EditorRename.abort':
-    case 'EditorRename.finish':
-    case 'EditorRename.open':
-      return ModuleId.EditorRename
-    case 'ElectronApp.exit':
-      return ModuleId.ElectronApp
-    case 'ElectronBrowserView.createBrowserViewQuickpick':
-    case 'ElectronBrowserView.openBrowserViewQuickPick':
-      return ModuleId.ElectronBrowserView
-    case 'ElectronClipBoard.writeText':
-      return ModuleId.ElectronClipBoard
-    case 'ElectronMenu.handleMenuClose':
-    case 'ElectronMenu.handleSelect':
-      return ModuleId.ElectronMenu
-    case 'ElectronWindow.close':
-    case 'ElectronWindow.maximize':
-    case 'ElectronWindow.minimize':
-    case 'ElectronWindow.toggleDevtools':
-    case 'ElectronWindow.unmaximize':
-    case 'ElectronWindow.zoomIn':
-    case 'ElectronWindow.zoomOut':
-      return ModuleId.ElectronWindow
-    case 'ErrorHandling.handleError':
-      return ModuleId.ErrorHandling
-    case 'Eval.evalInRendererProcess':
-      return ModuleId.Eval
-    case 'ExtensionHost.loadWebExtension':
-    case 'ExtensionHost.startWebExtensionHost':
-      return ModuleId.ExtensionHostCode
-    case 'ExtensionMeta.addExtension':
-    case 'ExtensionMeta.addNodeExtension':
-    case 'ExtensionMeta.addWebExtension':
-      return ModuleId.ExtensionMeta
-    case 'Extensions.openCachedExtensionsFolder':
-    case 'Extensions.openExtensionsFolder':
-      return ModuleId.Extensions
-    case 'FilePicker.showDirectoryPicker':
-    case 'FilePicker.showFilePicker':
-    case 'FilePicker.showSaveFilePicker':
-      return ModuleId.FilePicker
-    case 'FileSystem.getPathSeparator':
-    case 'FileSystem.mkdir':
-    case 'FileSystem.readDirWithFileTypes':
-    case 'FileSystem.readFile':
-    case 'FileSystem.remove':
-    case 'FileSystem.writeFile':
-      return ModuleId.FileSystem
-    case 'Format.hydrate':
-      return ModuleId.Format
-    case 'IconTheme.addIcons':
-    case 'IconTheme.getIconThemeCss':
-    case 'IconTheme.hydrate':
-      return ModuleId.IconTheme
-    case 'ImagePreview.hide':
-    case 'ImagePreview.show':
-      return ModuleId.ImagePreview
-    case 'IndexedDb.addHandle':
-    case 'IndexedDb.getHandle':
-      return ModuleId.IndexedDb
-    case 'KeyBindings.handleKeyBinding':
-    case 'KeyBindings.hydrate':
-      return ModuleId.KeyBindings
-    case 'KeyBindingsInitial.getKeyBindings':
-      return ModuleId.KeyBindingsInitial
-    case 3444:
-      return ModuleId.Listener
-    case 'LocalStorage.clear':
-    case 'LocalStorage.getItem':
-    case 'LocalStorage.getJson':
-    case 'LocalStorage.getText':
-    case 'LocalStorage.setJson':
-    case 'LocalStorage.setText':
-      return ModuleId.LocalStorage
-    case 'Menu.focusFirst':
-    case 'Menu.focusIndex':
-    case 'Menu.focusLast':
-    case 'Menu.focusNext':
-    case 'Menu.focusPrevious':
-    case 'Menu.handleMouseEnter':
-    case 'Menu.hide':
-    case 'Menu.selectIndex':
-    case 'Menu.selectItem':
-    case 'Menu.show':
-      return ModuleId.Menu
-    case 'Mime.getMediaMimeType':
-    case 'Mime.getTextMime':
-      return ModuleId.Mime
-    case 'Navigation.focusActivityBar':
-    case 'Navigation.focusMain':
-    case 'Navigation.focusNextPart':
-    case 'Navigation.focusPanel':
-    case 'Navigation.focusPreviousPart':
-    case 'Navigation.focusSideBar':
-    case 'Navigation.focusStatusBar':
-    case 'Navigation.focusTitleBar':
-      return ModuleId.Navigatiom
-    case 'Notification.create':
-    case 'Notification.dispose':
-    case 'Notification.handleClick':
-    case 'Notification.showWithOptions':
-      return ModuleId.Notification
-    case 'Open.openExternal':
-    case 'Open.openUrl':
-      return ModuleId.Open
-    case 'OpenNativeFolder.openNativeFolder':
-      return ModuleId.OpenNativeFolder
-    case 'PersistentFileHandle.addHandle':
-    case 'PersistentFileHandle.getHandle':
-    case 'PersistentFileHandle.removeHandle':
-      return ModuleId.PersistentFileHandle
-    case 'Preferences.hydrate':
-    case 'Preferences.openKeyBindingsJson':
-    case 'Preferences.openSettingsJson':
-      return ModuleId.Preferences
-    case 'RecentlyOpened.addToRecentlyOpened':
-    case 'RecentlyOpened.clearRecentlyOpened':
-    case 'RecentlyOpened.getRecentlyOpened':
-    case 'RecentlyOpened.hydrate':
-      return ModuleId.RecentlyOpened
-    case 'SaveState.handleVisibilityChange':
-    case 'SaveState.hydrate':
-      return ModuleId.SaveState
-    case 'ServiceWorker.hydrate':
-    case 'ServiceWorker.uninstall':
-      return ModuleId.ServiceWorker
-    case 'SessionReplay.downloadSession':
-    case 'SessionReplay.openSession':
-    case 'SessionReplay.replayCurrentSession':
-    case 'SessionReplay.replaySession':
-      return ModuleId.SessionReplay
-    case 'SessionStorage.clear':
-    case 'SessionStorage.getJson':
-      return ModuleId.SessionStorage
-    case 'Test.execute':
-      return ModuleId.Test
-    case '001':
-      return ModuleId.TestFramework
-    case '002':
-      return ModuleId.TestFrameworkComponent
-    case 'Url.createObjectUrl':
-    case 'Url.revokeObjectUrl':
-      return ModuleId.Url
-    case 'Viewlet.closeWidget':
-    case 'Viewlet.executeViewletCommand':
-    case 'Viewlet.focus':
-    case 'Viewlet.getAllStates':
-    case 'Viewlet.openWidget':
-    case 2133:
-      return ModuleId.Viewlet
-    case 'Window.close':
-    case 'Window.exit':
-    case 'Window.makeScreenshot':
-    case 'Window.maximize':
-    case 'Window.minimize':
-    case 'Window.openNew':
-    case 'Window.reload':
-    case 'Window.unmaximize':
-    case 'Window.zoomIn':
-    case 'Window.zoomOut':
-      return ModuleId.Window
-    case 'Workbench.unload':
-      return ModuleId.Workbench
-    case 'Workspace.hydrate':
-    case 'Workspace.setPath':
-    case 'Workspace.setUri':
-      return ModuleId.Workspace
-    default:
-      throw new Error(`command ${commandId} not found`)
-  }
-}