@lvce-editor/server 0.0.28 → 0.0.31

package/static/0e4d46a/packages/renderer-worker/src/parts/Navigation/Navigation.ipc.js

@@ -0,0 +1,12 @@
+import * as Navigation from './Navigation.js'
+
+export const Commands = {
+  'Navigation.focusPreviousPart': Navigation.focusPreviousPart,
+  'Navigation.focusNextPart': Navigation.focusNextPart,
+  'Navigation.focusActivityBar': Navigation.focusActivityBar,
+  'Navigation.focusStatusBar': Navigation.focusStatusBar,
+  'Navigation.focusPanel': Navigation.focusPanel,
+  'Navigation.focusSideBar': Navigation.focusSideBar,
+  'Navigation.focusTitleBar': Navigation.focusTitleBar,
+  'Navigation.focusMain': Navigation.focusMain,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/Notification/Notification.ipc.js

@@ -0,0 +1,8 @@
+import * as Notification from './Notification.js'
+
+export const Commands = {
+  'Notification.create': Notification.create,
+  'Notification.dispose': Notification.dispose,
+  'Notification.showWithOptions': Notification.showWithOptions,
+  'Notification.handleClick': Notification.handleClick,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/Open/Open.ipc.js

@@ -0,0 +1,6 @@
+import * as Open from './Open.js'
+
+export const Commands = {
+  'Open.openNativeFolder': Open.openNativeFolder,
+  'Open.openUrl': Open.openUrl,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/Open/Open.js

@@ -0,0 +1,25 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import { VError } from '../VError/VError.js'
+
+export const openNativeFolder = async (absolutePath) => {
+  try {
+    await SharedProcess.invoke(
+      /* Native.openFolder */ 'Native.openFolder',
+      /* path */ absolutePath
+    )
+  } catch (error) {
+    throw new VError(error, `Failed to open folder ${absolutePath}`)
+  }
+}
+
+export const openUrl = async (url) => {
+  try {
+    await RendererProcess.invoke(
+      /* Open.openUrl */ 'Open.openUrl',
+      /* url */ url
+    )
+  } catch (error) {
+    throw new VError(error, `Failed to open url ${url}`)
+  }
+}

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

@@ -0,0 +1,146 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.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) {
+    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
+}
+
+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 (getPlatform() === 'web') {
+    return 'settings'
+  }
+  return SharedProcess.invoke(
+    /* Platform.getUserSettingsPath */ 'Platform.getUserSettingsPath'
+  )
+}
+
+/**
+ * @returns {'electron'|'remote'|'web'|'test'}
+ */
+export const getPlatform = () => {
+  // @ts-ignore
+  if (typeof 'remote' !== 'undefined') {
+    // @ts-ignore
+    return 'remote'
+  }
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return 'test'
+  }
+
+  // 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 'electron'
+  }
+  return 'remote'
+}
+
+export const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof '/0e4d46a' !== 'undefined') {
+    // @ts-ignore
+    return '/0e4d46a'
+  }
+  if (getPlatform() === 'electron') {
+    return '../../../../..'
+  }
+  return ''
+}
+
+export const getRecentlyOpenedPath = () => {
+  if (getPlatform() === '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'
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/Preferences/Preferences.ipc.js

@@ -0,0 +1,10 @@
+import * as Preferences from './Preferences.js'
+
+// prettier-ignore
+export const Commands = {
+  // TODO rename to openKeyBindingsJson -> similar to openSettingsJson
+  // TODO is this needed?
+  'Preferences.openSettingsJson': Preferences.openSettingsJson,
+  'Preferences.openKeyBindingsJson': Preferences.openKeyBindingsJson,
+  'Preferences.hydrate': Preferences.hydrate,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/QuickPick/QuickPickCommand.js

@@ -0,0 +1,111 @@
+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'
+
+export const getPlaceholder = () => {
+  return 'Type the name of a command to run.'
+}
+
+export const helpEntries = () => {
+  return [
+    {
+      description: 'Show And Run Commands',
+      category: 'global commands',
+    },
+  ]
+}
+
+export const getLabel = () => {
+  return ''
+}
+
+export const getNoResults = () => {
+  return {
+    label: 'No matching results',
+  }
+}
+
+// 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()
+    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.getPlatform() === 'web') {
+    const builtinPicks = await getBuiltinPicks()
+    return builtinPicks
+  }
+  const builtinPicks = await getBuiltinPicks()
+  const extensionPicks = await getExtensionPicks()
+  return [...builtinPicks, ...extensionPicks]
+}
+
+const selectPickBuiltin = async (item) => {
+  // TODO ids should be all numbers for efficiency -> also directly can call command
+  await Command.execute(item.id)
+}
+
+const selectPickExtension = async (item) => {
+  console.log('ext pick', 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) {
+    ErrorHandling.showErrorDialog(error)
+    // console.log({ error })
+    // console.error(error)
+  }
+}
+
+export const selectPick = async (item) => {
+  if (item.id.startsWith('ext.')) {
+    await selectPickExtension(item)
+  } else {
+    await selectPickBuiltin(item)
+  }
+  return {
+    command: 'hide',
+  }
+}
+
+export const getFilterValue = (value) => {
+  return value
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/RecentlyOpened/RecentlyOpened.ipc.js

@@ -0,0 +1,9 @@
+import * as RecentlyOpened from './RecentlyOpened.js'
+
+// prettier-ignore
+export const Commands = {
+  'RecentlyOpened.getRecentlyOpened': RecentlyOpened.getRecentlyOpened,
+  'RecentlyOpened.clearRecentlyOpened': RecentlyOpened.clearRecentlyOpened,
+  'RecentlyOpened.addToRecentlyOpened': RecentlyOpened.addToRecentlyOpened,
+  'RecentlyOpened.hydrate': RecentlyOpened.hydrate,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/RendererProcess/RendererProcess.js

@@ -0,0 +1,116 @@
+/* istanbul ignore file */
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import { JsonRpcError } from '../Errors/Errors.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+
+export const state = {
+  pendingMessages: [],
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+const handleMessageFromRendererProcess = async (event) => {
+  const message = event.data
+  if (typeof message === 'string') {
+    console.warn(`unexpected message from renderer process: ${message}`)
+    return
+  }
+  if (message.id) {
+    if ('method' in message) {
+      try {
+        const result = await Command.execute(message.method, ...message.params)
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          result,
+        })
+        return
+      } catch (error) {
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          error,
+        })
+        return
+      }
+    }
+    Callback.resolve(message.id, message)
+    return
+  }
+  await Command.execute(message.method, ...message.params)
+}
+
+const getIpc = () => {
+  return IpcChild.listen({ method: IpcChild.Methods.Auto })
+}
+
+export const listen = async () => {
+  console.assert(state.pendingMessages.length === 0)
+  const ipc = await getIpc()
+  ipc.onmessage = handleMessageFromRendererProcess
+  state.ipc = ipc
+}
+
+/**
+ * @deprecated use invoke instead
+ * @param {*} message
+ */
+export const send = (message) => {
+  state.ipc.send(message)
+}
+
+const deserializeError = (serializedError) => {
+  const error = new Error()
+  if (serializedError && serializedError.message) {
+    error.message = serializedError.message
+  }
+  if (serializedError && serializedError.stack) {
+    error.stack = serializedError.stack
+  }
+  return error
+}
+
+const combineStacks = (upperStack, lowerStack) => {
+  const indexNewLine = lowerStack.indexOf('\n')
+  return upperStack + lowerStack.slice(indexNewLine)
+}
+
+class RendererProcessError extends Error {
+  constructor(serializedError) {
+    const deserializedError = deserializeError(serializedError)
+    super(deserializedError.message)
+    if (this.stack) {
+      this.stack = combineStacks(deserializedError.stack, this.stack)
+    }
+  }
+}
+
+export const invoke = async (method, ...parameters) => {
+  const responseMessage = await new Promise((resolve, reject) => {
+    const callbackId = Callback.register(resolve, reject)
+    if (!state.ipc) {
+      reject(new Error('ipc not active'))
+      return
+    }
+    state.ipc.send({
+      jsonrpc: '2.0',
+      method,
+      params: parameters,
+      id: callbackId,
+    })
+  })
+  if ('error' in responseMessage) {
+    throw new RendererProcessError(responseMessage.error)
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+  new JsonRpcError('unexpected message from renderer process')
+}
+
+export const sendAndTransfer = (message, transferables) => {
+  state.ipc.sendAndTransfer(message, transferables)
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/SaveState/SaveState.ipc.js

@@ -0,0 +1,7 @@
+import * as SaveState from './SaveState.js'
+
+// prettier-ignore
+export const Commands = {
+  'SaveState.hydrate': SaveState.hydrate,
+  'SaveState.handleVisibilityChange': SaveState.handleVisibilityChange,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/SaveState/SaveState.js

@@ -0,0 +1,45 @@
+// import * as Main from '../Main/Main.js'
+import * as LocalStorage from '../LocalStorage/LocalStorage.js'
+import * as Preferences from '../Preferences/Preferences.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SessionStorage from '../SessionStorage/SessionStorage.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as Workspace from '../Workspace/Workspace.js'
+
+const getStateToSave = () => {
+  const instances = ViewletStates.getAllInstances()
+  // const mainEditors = Main.state.editors
+  return {
+    instances,
+    mainEditors: [],
+    workspace: {
+      path: Workspace.state.workspacePath,
+      homeDir: Workspace.state.homeDir,
+      pathSeparator: Workspace.state.pathSeparator,
+      uri: Workspace.state.workspaceUri,
+    },
+  }
+}
+
+export const handleVisibilityChange = async (visibilityState) => {
+  console.log('[renderer worker] visibility changed to', visibilityState)
+  if (visibilityState === 'hidden') {
+    const stateToSave = getStateToSave()
+    await Promise.all([
+      LocalStorage.setJson('stateToSave', stateToSave),
+      SessionStorage.setJson('workspace', stateToSave.workspace),
+    ])
+    console.log('[renderer worker] state was saved')
+  }
+}
+
+export const hydrate = async () => {
+  // TODO should set up listener in renderer process
+  if (!Preferences.get('workbench.saveStateOnVisibilityChange')) {
+    console.info(
+      '[info] not saving state on visibility change - disabled by settings'
+    )
+    return
+  }
+  await RendererProcess.invoke('Window.onVisibilityChange')
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ServiceWorker/ServiceWorker.ipc.js

@@ -0,0 +1,6 @@
+import * as ServiceWorker from './ServiceWorker.js'
+
+export const Commands = {
+  'ServiceWorker.hydrate': ServiceWorker.hydrate,
+  'ServiceWorker.uninstall': ServiceWorker.uninstall,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/SessionReplay/SessionReplay.ipc.js

@@ -0,0 +1,9 @@
+import * as SessionReplay from './SessionReplay.js'
+
+// prettier-ignore
+export const Commands = {
+  'SessionReplay.downloadSession': SessionReplay.downloadSession,
+  'SessionReplay.replayCurrentSession': SessionReplay.replayCurrentSession,
+  'SessionReplay.replaySession': SessionReplay.replaySession,
+  'SessionReplay.openSession': SessionReplay.openSession,
+}