@lvce-editor/server 0.4.4 → 0.6.0

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

@@ -0,0 +1,219 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+/* istanbul ignore file */
+
+// TODO this should always be completely tree shaken out during build, maybe need to be marked as @__Pure for terser to work
+
+// TODO treeshake this function out when targeting electron
+
+export const isMobileOrTablet = () => {
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return false
+  }
+  // @ts-ignore
+  const userAgentData = navigator.userAgentData
+  if (userAgentData && userAgentData.mobile === true) {
+    return true
+  }
+  // copied from https://stackoverflow.com/questions/11381673/detecting-a-mobile-browser
+  let check = false
+  ;(function (a) {
+    if (
+      /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(
+        a
+      ) ||
+      /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[23]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(
+        a.slice(0, 4)
+      )
+    ) {
+      check = true
+    }
+    // @ts-ignore
+  })(navigator.userAgent || navigator.vendor || window.opera)
+  return check
+}
+
+const getIsChrome = () => {
+  if (typeof navigator === 'undefined') {
+    return false
+  }
+  if (
+    // @ts-ignore
+    navigator.userAgentData &&
+    // @ts-ignore
+    navigator.userAgentData.brands
+  ) {
+    // @ts-ignore
+    return navigator.userAgentData.brands.includes('Chromium')
+  }
+  return false
+}
+
+export const isChrome = getIsChrome()
+
+const getIsFirefox = () => {
+  if (typeof navigator === 'undefined') {
+    return false
+  }
+  if (
+    // @ts-ignore
+    navigator.userAgentData &&
+    // @ts-ignore
+    navigator.userAgentData.brands
+  ) {
+    // @ts-ignore
+    return navigator.userAgentData.brands.includes('Firefox')
+  }
+  return navigator.userAgent.toLowerCase().indexOf('firefox') > -1
+}
+
+export const isFirefox = getIsFirefox()
+
+export const getExtensionsPath = () => {
+  return SharedProcess.invoke(
+    /* Platform.getExtensionsPath */ 'Platform.getExtensionsPath'
+  )
+}
+
+export const getBuiltinExtensionsPath = () => {
+  return SharedProcess.invoke(
+    /* Platform.getBuiltinExtensionsPath */ 'Platform.getBuiltinExtensionsPath'
+  )
+}
+
+export const getDisabledExtensionsPath = () => {
+  return SharedProcess.invoke(
+    /* Platform.getDisabledExtensionsPath */ 'Platform.getDisabledExtensionsPath'
+  )
+}
+
+export const getCachedExtensionsPath = () => {
+  return SharedProcess.invoke(
+    /* Platform.getCachedExtensionsPath */ 'Platform.getCachedExtensionsPath'
+  )
+}
+
+export const getMarketPlaceUrl = () => {
+  // TODO this should be configurable via settings
+  // TODO in web this should be static
+  return SharedProcess.invoke(
+    /* Platform.getMarketPlaceUrl */ 'Platform.getMarketplaceUrl'
+  )
+}
+
+export const getLogsDir = () => {
+  return SharedProcess.invoke(/* Platform.getLogsDir */ 'Platform.getLogsDir')
+}
+
+export const getUserSettingsPath = () => {
+  if (platform === PlatformType.Web) {
+    return 'settings'
+  }
+  return SharedProcess.invoke(
+    /* Platform.getUserSettingsPath */ 'Platform.getUserSettingsPath'
+  )
+}
+
+/**
+ * @returns {'electron'|'remote'|'web'|'test'}
+ */
+const getPlatform = () => {
+  // @ts-ignore
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-ignore
+    return PLATFORM
+  }
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return 'test'
+  }
+  if (typeof location !== 'undefined' && location.search === '?web') {
+    return PlatformType.Web
+  }
+
+  // TODO don't use window here -> want to run renderer-worker as webworker
+  if (
+    typeof navigator !== 'undefined' &&
+    typeof navigator.appVersion !== 'undefined' &&
+    navigator.appVersion.includes('Electron')
+  ) {
+    return PlatformType.Electron
+  }
+  return PlatformType.Remote
+}
+
+export const platform = 'remote'
+
+export const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof '/fbac85f' !== 'undefined') {
+    // @ts-ignore
+    return '/fbac85f'
+  }
+  if (platform === PlatformType.Electron) {
+    return '../../../../..'
+  }
+  return ''
+}
+
+export const getRecentlyOpenedPath = () => {
+  if (platform === PlatformType.Web) {
+    return 'recently-opened'
+  }
+  return SharedProcess.invoke(
+    /* Platform.getRecentlyOpenedPath */ 'Platform.getRecentlyOpenedPath'
+  )
+}
+
+export const getConfigPath = () => {
+  return SharedProcess.invoke(
+    /* Platform.getConfigDir */ 'Platform.getConfigDir'
+  )
+}
+
+export const getCachePath = () => {
+  return SharedProcess.invoke(/* Platform.getCacheDir */ 'Platform.getCacheDir')
+}
+
+export const getExtensionHostWorkerUrl = () => {
+  return '/packages/extension-host-worker/src/extensionHostWorkerMain.js'
+}
+
+export const getGithubApiUrl = () => {
+  return `https://api.github.com`
+}
+
+export const getCacheName = () => {
+  return 'lvce-runtime'
+}
+
+const getTestPathRemote = () => {
+  return SharedProcess.invoke(/* Platform.getTestPath */ 'Platform.getTestPath')
+}
+
+const getTestPathWeb = () => {
+  return '/packages/extension-host-worker-tests'
+}
+
+export const getTestPath = () => {
+  switch (platform) {
+    case PlatformType.Electron:
+    case PlatformType.Remote:
+      return getTestPathRemote()
+    case PlatformType.Web:
+      return getTestPathWeb()
+  }
+}
+
+export const getNodePath = () => {
+  if (platform === PlatformType.Web) {
+    throw new Error('not implemented in web')
+  }
+  return SharedProcess.invoke(/* Platform.getNodePath */ 'Platform.getNodePath')
+}
+
+export const getTmpDir = () => {
+  if (platform === PlatformType.Web) {
+    throw new Error('not implemented in web')
+  }
+  return SharedProcess.invoke(/* Platform.getTmpDir */ 'Platform.getTmpDir')
+}

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

@@ -0,0 +1,112 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Json from '../Json/Json.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+
+export const state = Object.create(null)
+
+export const openSettingsJson = async () => {
+  await Command.execute(
+    /* Main.openUri */ 'Main.openUri',
+    /* uri */ 'app://settings.json'
+  )
+}
+
+export const openKeyBindingsJson = async () => {
+  await Command.execute(
+    /* Main.openUri */ 'Main.openUri',
+    /* uri */ 'app://keyBindings.json'
+  )
+}
+
+// TODO command for opening workspace settings
+
+const getPreferencesJson = async () => {
+  if (Platform.platform === PlatformType.Web) {
+    const cachedPreferences = await Command.execute(
+      /* LocalStorage.getJson */ 'LocalStorage.getJson',
+      /* key */ 'settings'
+    )
+    if (cachedPreferences) {
+      return cachedPreferences
+    }
+    const assetDir = Platform.getAssetDir()
+    const url = `${assetDir}/config/defaultSettings.json`
+    return Command.execute(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
+  }
+  return SharedProcess.invoke(/* Preferences.getAll */ 'Preferences.getAll')
+}
+
+const getPreferences = async () => {
+  // TODO cache preferences, but they should not be stale
+  const preferences = getPreferencesJson()
+  return preferences
+}
+
+export const hydrate = async () => {
+  try {
+    // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
+    // TODO probably not all preferences need to be kept in memory
+    const preferences = await getPreferences()
+    Object.assign(state, preferences)
+
+    const styles = []
+    const fontSize = preferences['editor.fontSize']
+    if (fontSize) {
+      styles.push(`  --EditorFontSize: ${fontSize}px;`)
+    }
+    const fontFamily = preferences['editor.fontFamily']
+    if (fontFamily) {
+      styles.push(`  --EditorFontFamily: ${fontFamily};`)
+    }
+    const lineHeight = preferences['editor.lineHeight']
+    if (lineHeight) {
+      styles.push(`  --EditorLineHeight: ${lineHeight}px;`)
+    }
+    const letterSpacing = preferences['editor.letterSpacing']
+    if (letterSpacing) {
+      styles.push(`  --EditorLetterSpacing: ${letterSpacing}px;`)
+    }
+    const css = `:root {
+${styles.join('\n')}
+}`
+    // TODO make Css.setInlineStyle a separate module in renderer-worker
+    await RendererProcess.invoke(
+      /* Css.setInlineStyle */ 'Css.setInlineStyle',
+      /* id */ 'Settings',
+      /* css */ css
+    )
+  } catch (error) {
+    console.error(error)
+  }
+}
+
+export const get = (key) => {
+  return state[key]
+}
+
+export const set = async (key, value) => {
+  state[key] = value
+  if (Platform.platform === 'web') {
+    const preferences = { ...state, [key]: value }
+    await Command.execute(
+      /* LocalStorage.setJson */ 'LocalStorage.setJson',
+      /* key */ 'preferences',
+      /* value */ preferences
+    )
+    return
+  }
+  const content = Json.stringify(state)
+  await FileSystem.writeFile('app://settings.json', content)
+}
+
+export const update = async (settings) => {
+  const newSettings = { ...state, ...settings }
+  const content = Json.stringify(newSettings)
+  await FileSystem.writeFile('app://settings.json', content)
+  await GlobalEventBus.emitEvent('preferences.changed')
+}

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

@@ -0,0 +1,20 @@
+import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+
+const getModule = () => {
+  switch (Platform.platform) {
+    case PlatformType.Electron:
+      return import('./ProcessExplorerElectron.js')
+    case PlatformType.Remote:
+      return import('./ProcessExplorerRemote.js')
+    case PlatformType.Web:
+      return import('./ProcessExplorerWeb.js')
+    default:
+      throw new Error('unsupported platform')
+  }
+}
+
+export const open = async () => {
+  const module = await getModule()
+  return module.open()
+}

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

@@ -0,0 +1,5 @@
+import * as ElectronWindowProcessExplorer from '../ElectronWindowProcessExplorer/ElectronWindowProcessExplorer.js'
+
+export const open = () => {
+  return ElectronWindowProcessExplorer.open()
+}

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

@@ -0,0 +1,3 @@
+export const open = () => {
+  throw new Error('not implemented')
+}

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

@@ -0,0 +1,3 @@
+export const open = () => {
+  throw new Error('not implemented')
+}

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

@@ -0,0 +1,11 @@
+export const Command = '>'
+
+export const Symbol = '@'
+
+export const WorkspaceSymbol = '#'
+
+export const GoToLine = ':'
+
+export const View = 'view '
+
+export const None = ''

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

@@ -0,0 +1,26 @@
+import * as QuickPickEntryId from '../QuickPickEntryId/QuickPickEntryId.js'
+
+// prettier-ignore
+export const load = (moduleId) => {
+  switch (moduleId) {
+    case QuickPickEntryId.CommandPalette:
+    case QuickPickEntryId.File:
+    case QuickPickEntryId.EveryThing:
+    case QuickPickEntryId.WorkspaceSymbol:
+      return import('../QuickPickEntriesEverything/QuickPickEntriesEverything.js')
+    case QuickPickEntryId.Noop:
+      return import('../QuickPickEntriesNoop/QuickPickNoop.js')
+    case QuickPickEntryId.Number:
+      return import('../QuickPickEntriesNumber/QuickPickEntriesNumber.js')
+    case QuickPickEntryId.Recent:
+      return import('../QuickPickEntriesOpenRecent/QuickPickEntriesOpenRecent.js')
+    case QuickPickEntryId.ColorTheme:
+      return import('../QuickPickEntriesColorTheme/QuickPickEntriesColorTheme.js')
+    case QuickPickEntryId.Symbol:
+      return import('../QuickPickEntriesSymbol/QuickPickEntriesSymbol.js')
+    case QuickPickEntryId.View:
+      return import('../QuickPickEntriesView/QuickPickEntriesView.js')
+    default:
+      throw new Error(`unknown module "${moduleId}"`)
+  }
+}

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

@@ -0,0 +1,76 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+/**
+ * @enum {string}
+ */
+export const UiStrings = {
+  NoMatchingColorThemesFound: 'No matching color themes found',
+  SelectColorTheme: 'Select Color Theme',
+}
+
+const getColorThemeNames = async () => {
+  if (Platform.platform === PlatformType.Web) {
+    const assetDir = Platform.getAssetDir()
+    const url = `${assetDir}/config/themes.json`
+    return Command.execute(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
+  }
+  return SharedProcess.invoke(
+    /* ExtensionHost.getColorThemeNames */ 'ExtensionHost.getColorThemeNames'
+  )
+}
+
+const setColorTheme = (id) => {
+  return Command.execute(
+    /* ColorTheme.setColorTheme */ 5611,
+    /* colorThemeId */ id
+  )
+}
+
+export const getPlaceholder = () => {
+  return UiStrings.SelectColorTheme
+}
+
+export const getLabel = () => {
+  return UiStrings.SelectColorTheme
+}
+
+const toPick = (colorThemeName) => {
+  return {
+    label: colorThemeName,
+  }
+}
+
+export const getPickLabel = (colorThemeName) => {
+  return colorThemeName
+}
+
+export const getPicks = async (searchValue) => {
+  const colorThemeNames = await getColorThemeNames()
+  console.log({ colorThemeNames })
+  const picks = colorThemeNames.map(toPick)
+  return picks
+}
+
+export const selectPick = async (item) => {
+  await setColorTheme(/* colorThemeId */ item.label)
+  return {
+    command: 'hide',
+  }
+}
+
+export const focusPick = async (item) => {
+  await setColorTheme(/* colorThemeId */ item.label)
+}
+
+export const getFilterValue = (value) => {
+  return value
+}
+
+export const getNoResults = () => {
+  return {
+    label: UiStrings.NoMatchingColorThemesFound,
+  }
+}

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

@@ -0,0 +1,136 @@
+import * as Command from '../Command/Command.js'
+import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
+import * as ExtensionHostCommands from '../ExtensionHost/ExtensionHostCommands.js'
+import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+
+/**
+ * @enum {string}
+ */
+export const UiStrings = {
+  TypeNameOfCommandToRun: 'Type the name of a command to run.',
+  ShowAndRunCommands: 'Show And Run Commands',
+  NoMatchingResults: 'No matching results',
+}
+
+export const name = 'command'
+
+export const getPlaceholder = () => {
+  return UiStrings.TypeNameOfCommandToRun
+}
+
+export const helpEntries = () => {
+  return [
+    {
+      description: UiStrings.ShowAndRunCommands,
+      category: 'global commands',
+    },
+  ]
+}
+
+export const getLabel = () => {
+  return ''
+}
+
+export const getNoResults = () => {
+  return {
+    label: UiStrings.NoMatchingResults,
+  }
+}
+
+// TODO combine Ajax with cache (specify strategy: cacheFirst, networkFirst)
+const getBuiltinPicks = async () => {
+  const assetDir = Platform.getAssetDir()
+  const url = `${assetDir}/config/builtinCommands.json`
+  const builtinPicks = await Command.execute(
+    /* Ajax.getJson */ 'Ajax.getJson',
+    /* url */ url
+  )
+  return builtinPicks
+}
+
+const prefixIdWithExt = (item) => {
+  if (!item.label) {
+    ErrorHandling.warn('[QuickPick] item has missing label', item)
+  }
+  if (!item.id) {
+    ErrorHandling.warn('[QuickPick] item has missing id', item)
+  }
+  return {
+    ...item,
+    id: `ext.${item.id}`,
+    label: item.label || item.id,
+  }
+}
+
+const getExtensionPicks = async () => {
+  try {
+    // TODO don't call this every time
+    const extensionPicks = await ExtensionHostCommands.getCommands()
+    console.log({ extensionPicks })
+    if (!extensionPicks) {
+      return []
+    }
+    const mappedPicks = extensionPicks.map(prefixIdWithExt)
+    return mappedPicks
+  } catch (error) {
+    console.error(`Failed to get extension picks: ${error}`)
+    return []
+  }
+}
+
+// TODO send strings to renderer process only once for next occurrence send uint16array of ids of strings
+
+export const getPicks = async () => {
+  if (Platform.platform === PlatformType.Web) {
+    const builtinPicks = await getBuiltinPicks()
+    return builtinPicks
+  }
+  const builtinPicks = await getBuiltinPicks()
+  const extensionPicks = await getExtensionPicks()
+  return [...builtinPicks, ...extensionPicks]
+}
+
+const shouldHide = (item) => {
+  if (item.id === 'Viewlet.openWidget' && item.args[0] === 'QuickPick') {
+    return false
+  }
+  return true
+}
+
+const selectPickBuiltin = async (item) => {
+  const args = item.args || []
+  // TODO ids should be all numbers for efficiency -> also directly can call command
+  await Command.execute(item.id, ...args)
+  if (shouldHide(item)) {
+    return {
+      command: 'hide',
+    }
+  }
+  return {
+    command: '',
+  }
+}
+
+const selectPickExtension = async (item) => {
+  const id = item.id.slice(4) // TODO lots of string allocation with 'ext.' find a better way to separate builtin commands from extension commands
+  try {
+    await ExtensionHostCommands.executeCommand(id)
+  } catch (error) {
+    await ErrorHandling.showErrorDialog(error)
+  }
+  return {
+    command: 'hide',
+  }
+}
+
+export const selectPick = (item) => {
+  if (item.id.startsWith('ext.')) {
+    return selectPickExtension(item)
+  }
+  return selectPickBuiltin(item)
+}
+
+export const getFilterValue = (value) => {
+  return value
+}