@lvce-editor/server 0.11.2 → 0.11.4

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

@@ -1,122 +0,0 @@
-import * as Command from '../Command/Command.js'
-
-// TODO use https://github.com/stack-tools-js/stack-tools to print error
-
-const enhanceErrorMessage = (error) => {
-  if (!error) {
-    return {
-      message: `Error: ${error}`,
-      stack: undefined,
-      codeFrame: undefined,
-    }
-  }
-  let message = `${error}`
-  while (error.cause) {
-    error = error.cause
-    message += `: ${error}`
-  }
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr,
-  }
-}
-
-// const getErrorMessage = (error) => {
-//   let message = ``
-//   if (error && error.message) {
-//     message += error.message
-//   }
-//   if (error && error.stack) {
-//     message += `\n${error.stack}`
-//   }
-//   if (error && error.cause) {
-//     message += getErrorMessage(error.cause)
-//   }
-//   return message
-// }
-
-// const printError = (error) => {
-//   const message = getErrorMessage(error)
-//   console.error(message)
-// }
-
-export const printError = (error) => {
-  if (error && error.message && error.codeFrame) {
-    console.error(`${error.message}\n\n${error.codeFrame}\n\n${error.stack}`)
-  } else {
-    console.error(error)
-    if (error && error.cause) {
-      console.error('caused by')
-      printError(error.cause)
-    }
-  }
-}
-
-export const state = {
-  /**
-   * @type {string[]}
-   */
-  seenWarnings: [],
-}
-
-export const handleError = async (error) => {
-  try {
-    printError(error)
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Notification.create */ 'Notification.create',
-      /* type */ 'error',
-      /* text */ enhancedErrorMessage.message
-    )
-  } catch {
-    // ignore
-  }
-}
-
-export const showErrorDialog = async (error) => {
-  try {
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Dialog.showMessage */ 'Dialog.showMessage',
-      /* message */ enhancedErrorMessage
-    )
-  } catch {
-    // ignore
-  }
-}
-
-export const warn = (...args) => {
-  const stringified = JSON.stringify(args)
-  if (state.seenWarnings.includes(stringified)) {
-    return
-  }
-  state.seenWarnings.push(stringified)
-  console.warn(...args)
-}
-
-/**
- * @param {PromiseRejectionEvent} event
- */
-export const handleUnhandledRejection = async (event) => {
-  try {
-    event.preventDefault()
-    await handleError(event.reason)
-  } catch {
-    console.error(event.reason)
-  }
-}
-
-/**
- * @param {ErrorEvent} event
- */
-export const handleUnhandledError = async (event) => {
-  try {
-    event.preventDefault()
-    await handleError(event.error)
-  } catch {
-    console.error(event.error)
-  }
-}

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

@@ -1,8 +0,0 @@
-import * as ExtensionHostCore from './ExtensionHostCore.js'
-
-// prettier-ignore
-export const Commands={
-
-  'ExtensionHost.loadWebExtension': ExtensionHostCore.loadWebExtension,
-  'ExtensionHost.startWebExtensionHost': ExtensionHostCore.startWebExtensionHost,
-}

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

@@ -1,89 +0,0 @@
-import * as ExtensionHostShared from './ExtensionHostShared.js'
-
-export const readFile = (protocol, path) => {
-  // TODO there shouldn't be multiple file system providers for the same protocol
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.readFile',
-    params: [protocol, path],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const remove = (protocol, path) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.remove',
-    params: [protocol, path],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-/**
- *
- * @param {string} protocol
- * @param {string} oldPath
- * @param {string} newPath
- */
-export const rename = (protocol, oldPath, newPath) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.rename',
-    params: [protocol, oldPath, newPath],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const mkdir = (protocol, path) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.mkdir',
-    params: [protocol, path],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const createFile = (protocol, path) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.writeFile',
-    params: [protocol, path, ''],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const createFolder = (protocol, path) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.createFolder',
-    params: [protocol, path],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const writeFile = (protocol, path, content) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.writeFile',
-    params: [protocol, path, content],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const readDirWithFileTypes = (protocol, path) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.readDirWithFileTypes',
-    params: [protocol, path],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}
-
-export const getPathSeparator = (protocol) => {
-  return ExtensionHostShared.executeProvider({
-    event: `onFileSystem:${protocol}`,
-    method: 'ExtensionHostFileSystem.getPathSeparator',
-    params: [protocol],
-    noProviderFoundMessage: 'no file system provider found',
-  })
-}

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

@@ -1,89 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import { JsonRpcError } from '../Errors/Errors.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-
-const isResultMessage = (message) => {
-  return 'result' in message
-}
-
-const isErrorMessage = (message) => {
-  return 'error' in message
-}
-
-const restoreError = (error) => {
-  if (error instanceof Error) {
-    return error
-  }
-  if (error.code && error.code === JsonRpcErrorCode.MethodNotFound) {
-    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
-}
-
-const handleMessageResult = (message) => {
-  Callback.resolve(message.id, message.result)
-}
-
-const handleMessageError = (message) => {
-  const restoredError = restoreError(message.error)
-  Callback.reject(message.id, restoredError)
-}
-
-const handleMessageMethod = async (message, event) => {
-  if (message.method === 'ElectronMessagePort.create') {
-    const IpcParentWithElectron = await import(
-      '../IpcParent/IpcParentWithElectron.js'
-    )
-    const ipc = await IpcParentWithElectron.create({
-      type: 'extension-host-helper-process',
-    })
-    event.target.postMessage(
-      {
-        jsonrpc: '2.0',
-        id: message.id,
-        result: ipc._port,
-      },
-      [ipc._port]
-    )
-    console.log({ ipc, event, target: event.target })
-  }
-}
-
-const handleMessage = (message, event) => {
-  if (message.id) {
-    if (isResultMessage(message)) {
-      handleMessageResult(message)
-    } else if (isErrorMessage(message)) {
-      handleMessageError(message)
-    } else if ('method' in message) {
-      handleMessageMethod(message, event)
-    } else {
-      throw new JsonRpcError('unexpected message type')
-    }
-  } else {
-    throw new JsonRpcError('unexpected message type')
-  }
-}
-
-export const listen = (ipc) => {
-  // TODO maybe pass handleMessage as paramter to make code more functional
-  ipc.onmessage = handleMessage
-  return {
-    invoke(method, ...params) {
-      return JsonRpc.invoke(ipc, method, ...params)
-    },
-  }
-}

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

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

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

@@ -1,27 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const showDirectoryPicker = async (options) => {
-  try {
-    return await RendererProcess.invoke(
-      'FilePicker.showDirectoryPicker',
-      options
-    )
-  } catch (error) {
-    if (
-      error &&
-      // @ts-ignore
-      error.message === 'window.showDirectoryPicker is not a function'
-    ) {
-      throw new Error(`showDirectoryPicker not supported on this browser`)
-    }
-    throw error
-  }
-}
-
-export const showFilePicker = (options) => {
-  return RendererProcess.invoke('FilePicker.showFilePicker', options)
-}
-
-export const showSaveFilePicker = (options) => {
-  return RendererProcess.invoke('FilePicker.showSaveFilePicker', options)
-}

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

@@ -1,159 +0,0 @@
-// TODO file system providers should be lazy loaded (maybe)
-
-import * as FileSystemExtensionHost from '../ExtensionHost/ExtensionHostFileSystem.js'
-import * as FileSystemProtocol from '../FileSystemProtocol/FileSystemProtocol.js'
-import * as FileSystemApp from './FileSystemApp.js'
-import * as FileSystemData from './FileSystemData.js'
-import * as FileSystemDisk from './FileSystemDisk.js'
-import * as FileSystemFetch from './FileSystemFetch.js'
-import * as FileSystemGitHub from './FileSystemGitHub.js'
-import * as FileSystemHtml from './FileSystemHtml.js'
-import * as FileSystemMemory from './FileSystemMemory.js'
-import * as FileSystemWeb from './FileSystemWeb.js'
-import * as EncodingType from '../EncodingType/EncodingType.js'
-
-// TODO when it rejects, it should throw a custom error,
-// FileSystemError
-
-// TODO lazyload different file system providers
-
-const RE_PROTOCOL = /^([a-z]+):\/\//
-
-export const getProtocol = (uri) => {
-  const protocolMatch = uri.match(RE_PROTOCOL)
-  if (protocolMatch) {
-    return protocolMatch[1]
-  }
-  return ''
-}
-
-export const state = {
-  fileSystems: Object.create(null),
-}
-
-// TODO extension host should be able to register arbitrary protocols (except app, http, https, file, )
-state.fileSystems[FileSystemProtocol.ExtensionHost] = FileSystemExtensionHost
-state.fileSystems[FileSystemProtocol.App] = FileSystemApp
-state.fileSystems[FileSystemProtocol.GitHub] = FileSystemGitHub
-state.fileSystems[FileSystemProtocol.Web] = FileSystemWeb
-state.fileSystems[FileSystemProtocol.Data] = FileSystemData
-state.fileSystems[FileSystemProtocol.Memfs] = FileSystemMemory
-state.fileSystems[FileSystemProtocol.Html] = FileSystemHtml
-state.fileSystems[FileSystemProtocol.Fetch] = FileSystemFetch
-
-const getFileSystem = (protocol) => {
-  return state.fileSystems[protocol] || FileSystemDisk
-}
-
-const PROTOCOL_POST_FIX_LENGTH = 3
-
-const getPath = (protocol, uri) => {
-  if (protocol === '') {
-    return uri
-  }
-  return uri.slice(protocol.length + PROTOCOL_POST_FIX_LENGTH)
-}
-
-export const readFile = (uri, encoding = EncodingType.Utf8) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.readFile(path, encoding)
-}
-
-export const remove = async (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  await fileSystem.remove(path)
-}
-
-export const rename = async (oldUri, newUri) => {
-  const protocol = getProtocol(oldUri)
-  const oldPath = getPath(protocol, oldUri)
-  const newPath = getPath(protocol, newUri)
-  const fileSystem = getFileSystem(protocol)
-  await fileSystem.rename(oldPath, newPath)
-}
-
-export const mkdir = async (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  await fileSystem.mkdir(path)
-}
-
-export const writeFile = async (uri, content, encoding = EncodingType.Utf8) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  await fileSystem.writeFile(path, content, encoding)
-}
-
-export const createFile = (uri) => {
-  return writeFile(uri, '')
-}
-
-export const readDirWithFileTypes = (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.readDirWithFileTypes(path)
-}
-
-export const unwatch = (id) => {
-  throw new Error('not implemented')
-}
-
-export const unwatchAll = () => {
-  throw new Error('not implemented')
-}
-
-export const getBlobUrl = (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.getBlobUrl(path)
-}
-
-export const copy = (sourceUri, targetUri) => {
-  // TODO what if it is not the same file system?
-  const protocol = getProtocol(sourceUri)
-  const fileSystem = getFileSystem(protocol)
-  const sourcePath = getPath(protocol, sourceUri)
-  const targetPath = getPath(protocol, targetUri)
-  return fileSystem.copy(sourcePath, targetPath)
-}
-
-export const getPathSeparator = (uri) => {
-  const protocol = getProtocol(uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.getPathSeparator(protocol)
-}
-
-export const getRealPath = (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.getRealPath(path)
-}
-
-export const stat = (uri) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.stat(path)
-}
-
-export const chmod = (uri, permissions) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.chmod(path, permissions)
-}
-
-export const canBeRestored = (uri) => {
-  const protocol = getProtocol(uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.canBeRestored
-}

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

@@ -1,22 +0,0 @@
-import * as Arrays from '../Arrays/Arrays.js'
-import * as Assert from '../Assert/Assert.js'
-
-export const getFile = (handle) => {
-  return handle.getFile()
-}
-
-export const write = async (handle, content) => {
-  const writable = await handle.createWritable()
-  await writable.write(content)
-  await writable.close()
-}
-
-export const getChildHandles = async (handle) => {
-  Assert.object(handle)
-  const handles = await Arrays.fromAsync(handle.values())
-  return handles
-}
-
-export const getFileHandle = (handle, name) => {
-  return handle.getFileHandle(name)
-}

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

@@ -1,7 +0,0 @@
-import * as Format from './Format.js'
-
-export const name = 'Format'
-
-export const Commands = {
-  'Format.hydrate': Format.hydrate,
-}

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

@@ -1,10 +0,0 @@
-import * as IconTheme from './IconTheme.js'
-
-export const name = 'IconTheme'
-
-export const Commands = {
-  hydrate: IconTheme.hydrate,
-  setIconTheme: IconTheme.setIconTheme,
-  // TODO command necessary?
-  // TODO hydrate should be an alias for reload/load
-}

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

@@ -1,49 +0,0 @@
-import * as WebSocketProtocol from '../WebSocketProtocol/WebSocketProtocol.js'
-
-const getWsUrl = () => {
-  const wsProtocol = WebSocketProtocol.getWebSocketProtocol()
-  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/96d5271/packages/renderer-worker/src/parts/Json/Json.js

@@ -1,14 +0,0 @@
-import { VError } from '../VError/VError.js'
-
-export const stringify = (value) => {
-  return JSON.stringify(value, null, 2) + '\n'
-}
-
-export const parse = (content) => {
-  // TODO use better json parse to throw more helpful error messages if json is invalid
-  try {
-    return JSON.parse(content)
-  } catch (error) {
-    throw new VError(error, 'failed to parse json')
-  }
-}

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

@@ -1,23 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const send = (transport, method, ...parameters) => {
-  transport.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params: parameters,
-  })
-}
-
-export const invoke = (transport, method, ...parameters) => {
-  return new Promise((resolve, reject) => {
-    // TODO use one map instead of two
-    const callbackId = Callback.register(resolve, reject)
-    transport.send({
-      jsonrpc: JsonRpcVersion.Two,
-      method,
-      params: parameters,
-      id: callbackId,
-    })
-  })
-}

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

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

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

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