@lvce-editor/server 0.11.2 → 0.11.3

package/static/96d5271/packages/renderer-worker/src/parts/Ajax/Ajax.js

@@ -1,72 +0,0 @@
-import ky, { HTTPError } from '../../../static/js/ky.js'
-import { VError } from '../VError/VError.js'
-import * as Assert from '../Assert/Assert.js'
-
-export const getJson = async (url, options = {}) => {
-  try {
-    Assert.string(url)
-    // cannot use ky(url).json() because it sets "accept: application/json"
-    // which doesn't work with preload, see
-    // https://stackoverflow.com/questions/41655955/why-are-preload-link-not-working-for-json-requests#answer-48645748
-    const response = await ky(url, options)
-    return response.json()
-  } catch (error) {
-    if (
-      error &&
-      error instanceof TypeError &&
-      error.message === 'Failed to fetch'
-    ) {
-      throw new VError(
-        `Failed to request json from "${url}". Make sure that the server is running and has CORS enabled`
-      )
-    }
-    if (error && error instanceof HTTPError) {
-      let json
-      try {
-        json = await error.response.json()
-      } catch {
-        throw error
-      }
-      if (json && json.message) {
-        throw new VError(
-          `Failed to request json from "${url}": ${json.message}`
-        )
-      }
-    }
-    // @ts-ignore
-    error.message = `Failed to request json from "${url}": ${error.message}`
-    throw error
-  }
-}
-
-export const getJsonLocal = (url) => {
-  return getJson(url, {
-    mode: 'no-cors',
-  })
-}
-
-export const getText = async (url, options = {}) => {
-  try {
-    return await ky(url, options).text()
-  } catch (error) {
-    if (
-      error &&
-      error instanceof TypeError &&
-      error.message === 'Failed to fetch'
-    ) {
-      throw new VError(
-        error,
-        `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`
-      )
-    }
-    throw new VError(error, `Failed to request text from "${url}"`)
-  }
-}
-
-export const getBlob = async (url, options = {}) => {
-  try {
-    return await ky(url, options).blob()
-  } catch (error) {
-    throw new VError(error, `Failed to request blob from "${url}"`)
-  }
-}

package/static/96d5271/packages/renderer-worker/src/parts/Arrays/Arrays.js

@@ -1,65 +0,0 @@
-// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
-
-export const insertInto = (array, start, newItems) => {
-  const originalLength = array.length
-  const newItemsLength = newItems.length
-  array.length = originalLength + newItemsLength
-  // Move the items after the start index, start from the end so that we don't overwrite any value.
-  for (let i = originalLength - 1; i >= start; i--) {
-    array[i + newItemsLength] = array[i]
-  }
-
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i]
-  }
-}
-
-/**
- * Alternative to the native Array.splice method, it
- * can only support limited number of items due to the maximum call stack size limit.
- */
-export const splice = (array, start, deleteCount, newItems) => {
-  const result = array.splice(start, deleteCount)
-  insertInto(array, start, newItems)
-  return result
-}
-
-export const last = (array) => {
-  return array[array.length - 1]
-}
-
-export const first = (array) => {
-  return array[0]
-}
-
-// TODO use this function more often
-export const firstIndex = (array) => {
-  return 0
-}
-
-// TODO use this function more often
-export const lastIndex = (array) => {
-  return array.length - 1
-}
-
-export const fromAsync = async (asyncIterable) => {
-  const children = []
-  for await (const value of asyncIterable) {
-    children.push(value)
-  }
-  return children
-}
-
-export const findObjectIndex = (array, key, value) => {
-  for (let i = 0; i < array.length; i++) {
-    const element = array[i]
-    if (element[key] === value) {
-      return i
-    }
-  }
-  return -1
-}
-
-export const isLastIndex = (array, index) => {
-  return index === array.length - 1
-}

package/static/96d5271/packages/renderer-worker/src/parts/BlobSrc/BlobSrc.js

@@ -1,38 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Procotol from '../Protocol/Protocol.js'
-
-const getSrcRemote = (uri) => {
-  const src = `/remote${uri}`
-  return src
-}
-
-const getSrcWithBlobUrl = async (uri) => {
-  const content = await FileSystem.readFile(uri)
-  const mimeType = await Command.execute('Mime.getMediaMimeType', uri)
-  const blob = await Command.execute(
-    'Blob.binaryStringToBlob',
-    content,
-    mimeType
-  )
-  const dataUrl = await Command.execute('Url.createObjectUrl', blob)
-  return dataUrl
-}
-
-const canUseRemoteLoading = (uri) => {
-  const protocol = FileSystem.getProtocol(uri)
-  return protocol === ''
-}
-
-export const getSrc = (uri) => {
-  if (canUseRemoteLoading(uri)) {
-    return getSrcRemote(uri)
-  }
-  return getSrcWithBlobUrl(uri)
-}
-
-export const disposeSrc = async (src) => {
-  if (src.startsWith(Procotol.Blob)) {
-    await Command.execute('Url.revokeObjectUrl', src)
-  }
-}

package/static/96d5271/packages/renderer-worker/src/parts/Chrome/Chrome.ipc.js

@@ -1,9 +0,0 @@
-import * as Chrome from './Chrome.js'
-
-export const Commands = {
-  'Chrome.close': Chrome.close,
-  'Chrome.exit': Chrome.exit,
-  'Chrome.maximize': Chrome.maximize,
-  'Chrome.minimize': Chrome.minimize,
-  'Chrome.unmaximize': Chrome.unmaximize,
-}

package/static/96d5271/packages/renderer-worker/src/parts/ChromeExtension/ChromeExtension.ipc.js

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

package/static/96d5271/packages/renderer-worker/src/parts/ColorThemeFromJson/ColorThemeFromJson.ipc.js

@@ -1,6 +0,0 @@
-import * as ColorThemeFromJson from './ColorThemeFromJson.js'
-
-// prettier-ignore
-export const Commands = {
-  'ColorThemeFromJson.createColorThemeFromJson': ColorThemeFromJson.createColorThemeFromJson
-}

package/static/96d5271/packages/renderer-worker/src/parts/Command/Command.js

@@ -1,67 +0,0 @@
-import * as Module from '../Module/Module.js'
-import * as ModuleMap from '../ModuleMap/ModuleMap.js'
-
-export const state = {
-  commands: Object.create(null),
-  pendingModules: Object.create(null),
-}
-
-const initializeModule = (module) => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = `${module.name}.${key}`
-        register(actualKey, value)
-      } else {
-        register(key, value)
-      }
-    }
-    return
-  }
-  throw new Error(
-    `module ${module.name} is missing an initialize function and commands`
-  )
-}
-
-const getOrLoadModule = (moduleId) => {
-  if (!state.pendingModules[moduleId]) {
-    const importPromise = Module.load(moduleId)
-    state.pendingModules[moduleId] = importPromise.then(initializeModule)
-  }
-  return state.pendingModules[moduleId]
-}
-
-const loadCommand = (command) => getOrLoadModule(ModuleMap.getModuleId(command))
-
-export const register = (commandId, listener) => {
-  state.commands[commandId] = listener
-}
-
-export const registerMultiple = (commands) => {
-  Object.assign(state.commands, commands)
-}
-
-const hasThrown = new Set()
-
-export const execute = (command, ...args) => {
-  if (command in state.commands) {
-    if (typeof state.commands[command] !== 'function') {
-      throw new Error(`[renderer-worker] Command ${command} is not a function`)
-    }
-    return state.commands[command](...args)
-  }
-  return (
-    loadCommand(command)
-      // TODO can skip then block in prod (only to prevent endless loop in dev)
-      .then(() => {
-        if (!(command in state.commands)) {
-          if (hasThrown.has(command)) {
-            return
-          }
-          hasThrown.add(command)
-          throw new Error(`Command did not register "${command}"`)
-        }
-        return execute(command, ...args)
-      })
-  )
-}

package/static/96d5271/packages/renderer-worker/src/parts/ContextMenu/ContextMenu.js

@@ -1,27 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Platform from '../Platform/Platform.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-import * as Preferences from '../Preferences/Preferences.js'
-
-const hasContextMenuNativePreference = () => {
-  const value = Preferences.get('window.titleBarStyle')
-  return value === 'native'
-}
-
-const getModule = () => {
-  if (
-    Platform.platform === PlatformType.Electron &&
-    hasContextMenuNativePreference()
-  ) {
-    return import('./ContextMenuElectron.js')
-  }
-  return import('./ContextMenuBrowser.js')
-}
-
-export const show = async (x, y, id) => {
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(id)
-  const module = await getModule()
-  return module.show(x, y, id)
-}

package/static/96d5271/packages/renderer-worker/src/parts/ContextMenu/ContextMenuBrowser.js

@@ -1,15 +0,0 @@
-import * as Menu from '../Menu/Menu.js'
-import * as Assert from '../Assert/Assert.js'
-import * as Platform from '../Platform/Platform.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-import * as MenuEntries from '../MenuEntries/MenuEntries.js'
-import * as ElectronMenu from '../ElectronMenu/ElectronMenu.js'
-
-export const show = async (x, y, id) => {
-  await Menu.hide()
-  // TODO handle error
-  // TODO race condition
-  await Menu.show(x, y, id, /* mouseBlocking */ true)
-  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
-  // TODO what about separators?
-}

package/static/96d5271/packages/renderer-worker/src/parts/ContextMenu/ContextMenuElectron.js

@@ -1,5 +0,0 @@
-import * as ElectronMenu from '../ElectronMenu/ElectronMenu.js'
-
-export const show = (x, y, id) => {
-  return ElectronMenu.openContextMenu(x, y, id)
-}

package/static/96d5271/packages/renderer-worker/src/parts/Dialog/Dialog.js

@@ -1,195 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ElectronDialog from '../ElectronDialog/ElectronDialog.js'
-import * as ElectronWindowAbout from '../ElectronWindowAbout/ElectronWindowAbout.js'
-import * as Platform from '../Platform/Platform.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  dialog: undefined,
-}
-
-const isAbortError = (error) => {
-  if (error && error.message === 'The user aborted a request.') {
-    return true
-  }
-  return false
-}
-
-const openFolderWeb = async () => {
-  try {
-    const result = await Command.execute('FilePicker.showDirectoryPicker', {
-      startIn: 'pictures',
-      mode: 'readwrite',
-    })
-    await Command.execute('PersistentFileHandle.addHandle',`html://${result.name}`,  result)
-    await Command.execute('Workspace.setPath', `html://${result.name}`)
-  } catch (error) {
-    if (isAbortError(error)) {
-      return
-    }
-    throw new VError(error, `Failed to open folder`)
-  }
-}
-
-const openFolderRemote = async () => {
-  const path = await RendererProcess.invoke(
-    /* Dialog.prompt */ 'Dialog.prompt',
-    /* message */ 'Choose path:'
-  )
-  if (!path) {
-    return
-  }
-  await Command.execute(
-    /* Workspace.setPath */ 'Workspace.setPath',
-    /* path */ path
-  )
-}
-
-const openFolderElectron = async () => {
-  const folders = await ElectronDialog.showOpenDialog(
-    /* title */ 'Open Folder',
-    /* properties */ ['openDirectory', 'dontAddToRecent', 'showHiddenFiles']
-  )
-  if (!folders || folders.length === 0) {
-    return
-  }
-  const path = folders[0]
-  await Command.execute(
-    /* Workspace.setPath */ 'Workspace.setPath',
-    /* path */ path
-  )
-}
-
-export const openFolder = () => {
-  switch (Platform.platform) {
-    case PlatformType.Web:
-      return openFolderWeb()
-    case PlatformType.Remote:
-      return openFolderRemote()
-    case PlatformType.Electron:
-      return openFolderElectron()
-    default:
-      return
-  }
-}
-
-const openFileWeb = () => {
-  console.warn('open file - not implemented')
-}
-
-const openFileRemote = () => {
-  console.warn('open file - not implemented')
-}
-
-const openFileElectron = async () => {
-  const [file] = await ElectronDialog.showOpenDialog('Open File', [
-    'openFile',
-    'dontAddToRecent',
-    'showHiddenFiles',
-  ])
-  await Command.execute('Main.openUri', file)
-}
-
-export const openFile = () => {
-  switch (Platform.platform) {
-    case PlatformType.Web:
-      return openFileWeb()
-    case PlatformType.Remote:
-      return openFileRemote()
-    case PlatformType.Electron:
-      return openFileElectron()
-    default:
-      return
-  }
-}
-
-const showAboutWeb = () => {
-  console.warn('show about - not implemented')
-}
-
-const showAboutRemote = () => {
-  console.warn('show about - not implemented')
-}
-
-const showAboutElectron = async () => {
-  await ElectronWindowAbout.open()
-}
-
-export const showAbout = async () => {
-  switch (Platform.platform) {
-    case 'web':
-      return showAboutWeb()
-    case 'remote':
-      return showAboutRemote()
-    case 'electron':
-      return showAboutElectron()
-    default:
-      return
-  }
-}
-
-export const showMessage = async (message, options) => {
-  if (state.dialog) {
-    console.info('cannot show multiple dialogs at the same time', message)
-    return
-  }
-  // TODO implement actual dialog component for web
-  // RendererProcess.invoke(/* Dialog.alert */ 7834, /* message */ message)
-  // TODO on electron use native dialog
-  if (!options) {
-    options = ['Show Command Output', 'Cancel', 'Open Git Log']
-  }
-  // @ts-ignore
-  state.dialog = {
-    message,
-    options,
-  }
-
-  if (Platform.platform === 'electron') {
-    const index = await ElectronDialog.showMessageBox(
-      /* message */ message.message,
-      /* buttons */ options
-    )
-
-    if (index === -1) {
-      // TODO can this even happen?
-      return
-    }
-    await handleClick(index)
-  } else {
-    await RendererProcess.invoke(
-      /* Dialog.showErrorDialogWithOptions */ 'Dialog.showErrorDialogWithOptions',
-      /* message */ message,
-      /* options */ options
-    )
-  }
-}
-
-export const close = async () => {
-  // TODO support closing of electron dialogs
-  if (!state.dialog) {
-    console.info('no dialog to close')
-    return
-  }
-  state.dialog = undefined
-  await RendererProcess.invoke(/* Dialog.close */ 7836)
-}
-
-export const handleClick = async (index) => {
-  const dialog = state.dialog
-  const option = dialog.options[index]
-  // TODO handle case when index is out of bounds
-  switch (option) {
-    case 'Show Command Output':
-      await close()
-      const uri = `data://${dialog.message.stderr}`
-      await Command.execute(/* Main.openUri */ 'Main.openUri', uri)
-      // TODO show stderr in editor
-      // TODO close dialog
-      break
-    default:
-      break
-  }
-}

package/static/96d5271/packages/renderer-worker/src/parts/DomMatrix/DomMatrix.js

@@ -1,43 +0,0 @@
-export const create = (init = [1, 0, 0, 1, 0, 0]) => {
-  return new DOMMatrix(init)
-}
-
-export const scaleUp = (domMatrix, deltaScale) => {
-  return new DOMMatrix([
-    (domMatrix.a *= deltaScale),
-    domMatrix.b,
-    domMatrix.c,
-    (domMatrix.d *= deltaScale),
-    domMatrix.e,
-    domMatrix.f,
-  ])
-}
-
-export const scaleDown = (domMatrix, deltaScale) => {
-  return scaleUp(domMatrix, 1 / deltaScale)
-}
-
-export const zoomInto = (domMatrix, zoomFactor, relativeX, relativeY) => {
-  return new DOMMatrix()
-    .translateSelf(relativeX, relativeY)
-    .scaleSelf(zoomFactor)
-    .translateSelf(-relativeX, -relativeY)
-    .multiplySelf(domMatrix)
-}
-
-// workaround for browser bug
-export const toString = (domMatrix) => {
-  const { a, b, c, d, e, f } = domMatrix
-  return `matrix(${a}, ${b}, ${c}, ${d}, ${e}, ${f})`
-}
-
-export const move = (domMatrix, deltaX, deltaY) => {
-  return new DOMMatrix([
-    domMatrix.a,
-    domMatrix.b,
-    domMatrix.c,
-    domMatrix.d,
-    domMatrix.e + deltaX,
-    domMatrix.f + deltaY,
-  ])
-}

package/static/96d5271/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSave.js

@@ -1,34 +0,0 @@
-import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Preferences from '../Preferences/Preferences.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import { VError } from '../VError/VError.js'
-import * as EditorFormat from './EditorCommandFormat.js'
-
-const getFormatOnSave = () => {
-  const value = Preferences.get('editor.formatOnSave')
-  return Boolean(value)
-}
-
-const getNewEditor = async (editor) => {
-  const formatOnSave = getFormatOnSave()
-  if (formatOnSave) {
-    return EditorFormat.format(editor)
-  }
-  return editor
-}
-
-export const save = async (editor) => {
-  try {
-    const uri = editor.uri
-    const newEditor = await getNewEditor(editor)
-    const content = TextDocument.getText(newEditor)
-    await FileSystem.writeFile(uri, content)
-    return newEditor
-  } catch (error) {
-    // @ts-ignore
-    const betterError = new VError(error, `Failed to save file "${editor.uri}"`)
-    await ErrorHandling.handleError(betterError)
-    return
-  }
-}

package/static/96d5271/packages/renderer-worker/src/parts/ElectronProcess/ElectronProcess.js

@@ -1,75 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import { JsonRpcError } from '../Errors/Errors.js'
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-
-export const state = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-}
-
-const createIpc = async () => {
-  return IpcParent.create({
-    method: IpcParentType.ElectronMessagePort,
-    type: 'electron-process',
-  })
-}
-
-const handleMessage = async (message) => {
-  if ('id' in message) {
-    Callback.resolve(message.id, message)
-  } else if ('method' in message) {
-    await Command.execute(message.method, ...message.params)
-  }
-}
-
-// TODO race condition
-const getIpc = async () => {
-  if (!state.ipc) {
-    const ipc = await createIpc()
-    ipc.onmessage = handleMessage
-    state.ipc = ipc
-  }
-  return state.ipc
-}
-
-const restoreError = (error) => {
-  if (error instanceof Error) {
-    return error
-  }
-  if (error.code && error.code === JsonRpcErrorCode.MethodNotFound) {
-    console.log('create json rpc error')
-    const restoredError = new JsonRpcError(error.message)
-    restoredError.stack = error.stack
-    return restoredError
-  }
-  const restoredError = new Error(error.message)
-  if (error.data) {
-    if (error.data.stack) {
-      restoredError.stack = error.data.stack
-    }
-    if (error.data.codeFrame) {
-      // @ts-ignore
-      restoredError.codeFrame = error.data.codeFrame
-    }
-  }
-  return restoredError
-}
-
-export const invoke = async (method, ...params) => {
-  const ipc = await getIpc()
-  const response = await JsonRpc.invoke(ipc, method, ...params)
-  if ('result' in response) {
-    return response.result
-  }
-  if ('error' in response) {
-    const restoredError = restoreError(response.error)
-    throw restoredError
-  }
-  throw new Error('unexpected response')
-}

package/static/96d5271/packages/renderer-worker/src/parts/ElectronWindowAbout/ElectronWindowAbout.js

@@ -1,5 +0,0 @@
-import * as ElectronProcess from '../ElectronProcess/ElectronProcess.js'
-
-export const open = async () => {
-  await ElectronProcess.invoke('ElectronWindowAbout.open')
-}

package/static/96d5271/packages/renderer-worker/src/parts/ElectronWindowProcessExplorer/ElectronWindowProcessExplorer.js

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