@lvce-editor/server 0.4.4 → 0.6.0

package/static/3d96d42/packages/renderer-worker/src/parts/EditorCommand/EditorCommandToggleLineComment.js

@@ -1,105 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as Languages from '../Languages/Languages.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-// TODO
-const getLanguageAtPosition = (position) => {
-  return 'html'
-}
-
-const getLineComment = async (editor) => {
-  const languageConfiguration = await Languages.getLanguageConfiguration(editor)
-  if (
-    !languageConfiguration ||
-    !languageConfiguration.comments ||
-    !languageConfiguration.comments.lineComment
-  ) {
-    return undefined
-  }
-  return languageConfiguration.comments.lineComment
-}
-
-const getBlockComment = async (languageId) => {
-  const languageConfiguration = await Languages.getLanguageConfiguration(
-    languageId
-  )
-  if (
-    !languageConfiguration ||
-    !languageConfiguration.comments ||
-    !languageConfiguration.comments.blockComment
-  ) {
-    return undefined
-  }
-  return languageConfiguration.comments.blockComment
-}
-
-const RE_WHITESPACE_AT_START = /^\s+/
-
-const getLineCommentEdit = (rowIndex, line, lineComment) => {
-  const whitespaceMatch = line.match(RE_WHITESPACE_AT_START)
-  const index = whitespaceMatch ? whitespaceMatch[0] : 0
-  if (line.slice(index).startsWith(lineComment)) {
-    // TODO also check tab character
-    if (line[index + lineComment.length] === ' ') {
-      return {
-        inserted: [''],
-        deleted: [lineComment.length + 1],
-        start: {
-          rowIndex,
-          columnIndex: index,
-        },
-        end: {
-          rowIndex,
-          columnIndex: index + lineComment.length + 1,
-        },
-        type: /* singleLineEdit */ 1,
-      }
-    }
-    return {
-      inserted: [''],
-      deleted: [lineComment],
-      start: {
-        rowIndex,
-        columnIndex: index,
-      },
-      end: {
-        rowIndex,
-        columnIndex: index + lineComment.length,
-      },
-      type: /* singleLineEdit */ 1,
-    }
-  }
-  return {
-    inserted: [`${lineComment} `],
-    deleted: [],
-    start: {
-      rowIndex,
-      columnIndex: index,
-    },
-    end: {
-      rowIndex,
-      columnIndex: index,
-    },
-    type: /* singleLineEdit */ 1,
-  }
-}
-
-export const editorToggleLineComment = async (editor) => {
-  console.log('TOGGLE COMMENT')
-
-  const lineComment = await getLineComment(editor)
-  if (!lineComment) {
-    return editor
-  }
-  // replaceSelections(editor, lineComment, 'editorToggleLineComment')
-  const textDocument = editor
-  const cursorRowIndex = editor.selections[0]
-  const line = TextDocument.getLine(textDocument, cursorRowIndex)
-  const documentEdits = [getLineCommentEdit(cursorRowIndex, line, lineComment)]
-  // TODO cursor edits should be computed automatically from document edits
-  // console.log({ documentEdits })
-  // const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
-  // return cursor
-  // })
-  return Editor.scheduleDocumentAndCursorsSelections(editor, documentEdits)
-}

package/static/3d96d42/packages/renderer-worker/src/parts/ElectronWindow/ElectronWindow.js

@@ -1,29 +0,0 @@
-import * as ElectronProcess from '../ElectronProcess/ElectronProcess.js'
-
-export const reload = () => {
-  return ElectronProcess.invoke('ElectronWindow.reload')
-}
-
-export const minimize = () => {
-  return ElectronProcess.invoke('ElectronWindow.minimize')
-}
-
-export const unmaximize = () => {
-  return ElectronProcess.invoke('ElectronWindow.unmaximize')
-}
-
-export const maximize = () => {
-  return ElectronProcess.invoke('ElectronWindow.maximize')
-}
-
-export const close = () => {
-  return ElectronProcess.invoke('ElectronWindow.close')
-}
-
-export const openNew = (url) => {
-  return ElectronProcess.invoke('AppWindow.openNew', url)
-}
-
-export const toggleDevtools = () => {
-  return ElectronProcess.invoke('ElectronWindow.toggleDevtools')
-}

package/static/3d96d42/packages/renderer-worker/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,99 +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}`
-  }
-  console.log({ 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)
-}

package/static/3d96d42/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostLanguages.js

@@ -1,38 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Platform from '../Platform/Platform.js'
-import * as SharedProcess from '../SharedProcess/SharedProcess.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-
-const getLanguagesFromExtensionHost = async () => {
-  // TODO handle error
-  const languages = await SharedProcess.invoke(
-    /* ExtensionHost.getLanguages */ 'ExtensionHost.getLanguages'
-  )
-  return languages
-}
-
-const getLanguagesFromStaticFolder = async () => {
-  const assetDir = Platform.getAssetDir()
-  const url = `${assetDir}/config/languages.json`
-  // TODO handle error ?
-  return Command.execute(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
-}
-
-export const getLanguages = () => {
-  if (Platform.platform === PlatformType.Web) {
-    return getLanguagesFromStaticFolder()
-  }
-  return getLanguagesFromExtensionHost()
-}
-
-export const getLanguageConfiguration = async (languageId) => {
-  if (Platform.platform === PlatformType.Web) {
-    console.warn('get language configuration not yet supported on web')
-    return
-  }
-  const languageConfiguration = await SharedProcess.invoke(
-    /* ExtensionHost.getLanguageConfiguration */ 'ExtensionHost.getLanguageConfiguration',
-    /* languageId */ languageId
-  )
-  return languageConfiguration
-}

package/static/3d96d42/packages/renderer-worker/src/parts/ExtensionMeta/ExtensionMeta.js

@@ -1,148 +0,0 @@
-import * as Platform from '../Platform/Platform.js'
-import * as Command from '../Command/Command.js'
-import * as SharedProcess from '../SharedProcess/SharedProcess.js'
-import * as Languages from '../Languages/Languages.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import { VError } from '../VError/VError.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-
-export const state = {
-  /**
-   * @type {any[]}
-   */
-  webExtensions: [],
-}
-
-const getId = (path) => {
-  const slashIndex = path.lastIndexOf('/')
-  return path.slice(slashIndex + 1)
-}
-
-const getWebExtensionManifest = async (path) => {
-  try {
-    const manifestPath = `${path}/extension.json`
-    const manifest = await Command.execute(
-      /* Ajax.getJson */ 'Ajax.getJson',
-      /* url */ manifestPath
-    )
-    return {
-      ...manifest,
-      path,
-    }
-  } catch (error) {
-    const id = getId(path)
-    throw new VError(error, `Failed to load extension manifest for ${id}`)
-  }
-}
-
-export const addWebExtension = async (path) => {
-  const manifest = await getWebExtensionManifest(path)
-  // TODO avoid side effect here
-  if (manifest.languages) {
-    for (const language of manifest.languages) {
-      if (language.tokenize) {
-        language.tokenize = manifest.path + '/' + language.tokenize
-      }
-    }
-  }
-  manifest.status = ExtensionManifestStatus.Resolved
-  state.webExtensions.push(manifest)
-  if (manifest.languages) {
-    // TODO handle case when languages is not of type array
-    await Languages.addLanguages(manifest.languages)
-  }
-}
-
-const getSharedProcessExtensions = () => {
-  return SharedProcess.invoke(
-    /* ExtensionManagement.getExtensions */ 'ExtensionManagement.getExtensions'
-  )
-}
-
-// TODO status fulfilled should be handled as resolved
-export const organizeExtensions = (extensions) => {
-  const rejected = []
-  const resolved = []
-  for (const extension of extensions) {
-    switch (extension.status) {
-      case ExtensionManifestStatus.Resolved:
-        resolved.push(extension)
-        break
-      case ExtensionManifestStatus.Rejected:
-        rejected.push(extension)
-        break
-      default:
-        break
-    }
-  }
-  return {
-    resolved,
-    rejected,
-  }
-}
-
-export const filterByMatchingEvent = (extensions, event) => {
-  const extensionsToActivate = []
-  for (const extension of extensions) {
-    // TODO handle error when extension.activation is not of type array (null or number or ...)
-    if (extension.activation && extension.activation.includes(event)) {
-      extensionsToActivate.push(extension)
-    }
-  }
-  return extensionsToActivate
-}
-
-const getCodeFrameFromError = (error) => {
-  if (error && error.jse_cause && error.jse_cause.codeFrame) {
-    return error.jse_cause.codeFrame
-  }
-  return ''
-}
-
-const getOriginalStackFromError = (error) => {
-  if (error && error.originalStack) {
-    return error.originalStack
-  }
-  return ''
-}
-
-const handleRejectedExtension = async (extension) => {
-  const message = extension.reason.message
-  if (
-    message.includes(`Failed to load extension manifest: File not found`) ||
-    message.includes(`Failed to load extension manifest: ENOTDIR`)
-  ) {
-    return
-  }
-  const codeFrame = getCodeFrameFromError(extension.reason)
-  const stack = getOriginalStackFromError(extension.reason)
-  await Command.execute(
-    /* Dialog.showMessage */ 'Dialog.showMessage',
-    /* error */ { message, codeFrame, stack }
-  )
-}
-
-export const handleRejectedExtensions = async (extensions) => {
-  for (const extension of extensions) {
-    await handleRejectedExtension(extension)
-  }
-}
-
-export const getExtensions = async () => {
-  if (Platform.platform === PlatformType.Web) {
-    return state.webExtensions
-  }
-  if (Platform.platform === PlatformType.Remote) {
-    const sharedProcessExtensions = await getSharedProcessExtensions()
-    return [...sharedProcessExtensions, ...state.webExtensions]
-  }
-  const extensions = await getSharedProcessExtensions()
-  return extensions
-}
-
-export const addNodeExtension = async (path) => {
-  // TODO add support for dynamically loading node extensions
-  // e.g. for testing multiple extensions
-  throw new Error('not implemented')
-}

package/static/3d96d42/packages/renderer-worker/src/parts/FileSystem/FileSystem.js

@@ -1,142 +0,0 @@
-// TODO file system providers should be lazy loaded (maybe)
-
-import * as FileSystemExtensionHost from '../ExtensionHost/ExtensionHostFileSystem.js'
-import * as FileSystemApp from './FileSystemApp.js'
-import * as FileSystemDisk from './FileSystemDisk.js'
-import * as FileSystemGitHub from './FileSystemGitHub.js'
-import * as FileSystemWeb from './FileSystemWeb.js'
-import * as FileSystemData from './FileSystemData.js'
-import * as FileSystemMemory from './FileSystemMemory.js'
-// TODO when it rejects, it should throw a custom error,
-// FileSystemError
-
-// TODO lazyload different file system providers
-
-const RE_PROTOCOL = /^([a-z]+):\/\//
-
-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['extension-host'] = FileSystemExtensionHost
-state.fileSystems.app = FileSystemApp
-state.fileSystems.github = FileSystemGitHub
-state.fileSystems.web = FileSystemWeb
-state.fileSystems.data = FileSystemData
-state.fileSystems.memfs = FileSystemMemory
-
-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) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  return fileSystem.readFile(path)
-}
-
-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) => {
-  const protocol = getProtocol(uri)
-  const path = getPath(protocol, uri)
-  const fileSystem = getFileSystem(protocol)
-  await fileSystem.writeFile(path, content)
-}
-
-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)
-}

package/static/3d96d42/packages/renderer-worker/src/parts/FileSystem/FileSystemApp.js

@@ -1,48 +0,0 @@
-export const name = 'App'
-
-const getModule = (uri) => {
-  switch (uri) {
-    case 'startup-performance':
-      return import('./FileSystemAppStartupPerformance.js')
-    case 'memory-usage':
-      return import('./FileSystemAppMemoryUsage.js')
-    case 'settings.json':
-      return import('./FileSystemAppSettings.js')
-    case 'recently-opened.json':
-      return import('./FileSystemAppRecentlyOpened.js')
-    case 'session.json':
-      return import('./FileSystemAppSession.js')
-    default:
-      throw new Error(`unsupported file: ${uri}`)
-  }
-}
-
-export const readFile = async (uri) => {
-  const module = await getModule(uri)
-  return module.readFile()
-}
-
-export const writeFile = async (uri, content) => {
-  const module = await getModule(uri)
-  return module.writeFile(content)
-}
-
-export const readDirWithFileTypes = () => {
-  return []
-}
-
-export const rename = async (oldUri, newUri) => {
-  throw new Error('not allowed')
-}
-
-export const remove = async (path) => {
-  throw new Error('not allowed')
-}
-
-export const mkdir = async (path) => {
-  throw new Error('not allowed')
-}
-
-export const getPathSeparator = () => {
-  return '/'
-}

package/static/3d96d42/packages/renderer-worker/src/parts/FileSystem/FileSystemAppSettings.js

@@ -1,13 +0,0 @@
-import * as Platform from '../Platform/Platform.js'
-import * as FileSystemAppShared from './FileSystemAppShared.js'
-
-export const readFile = () => {
-  return FileSystemAppShared.readFileInternal(Platform.getUserSettingsPath)
-}
-
-export const writeFile = (content) => {
-  return FileSystemAppShared.writeFileInternal(
-    Platform.getUserSettingsPath,
-    content
-  )
-}

package/static/3d96d42/packages/renderer-worker/src/parts/FileSystem/FileSystemAppShared.js

@@ -1,60 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Platform from '../Platform/Platform.js'
-import * as Workspace from '../Workspace/Workspace.js'
-import * as Assert from '../Assert/Assert.js'
-import * as LocalStorage from '../LocalStorage/LocalStorage.js'
-import * as FileSystemDisk from './FileSystemDisk.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-
-export const readFileInternal = async (getPath) => {
-  const path = await getPath()
-  Assert.string(path)
-  if (Platform.platform === PlatformType.Web) {
-    const settingsJsonContent = await LocalStorage.getText(path)
-    if (settingsJsonContent) {
-      return settingsJsonContent
-    }
-    const assetDir = Platform.getAssetDir()
-    const url = `${assetDir}/config/defaultSettings.json`
-    return Command.execute(/* Ajax.getText */ 'Ajax.getText', /* url */ url)
-  }
-  // TODO handle enoent and other errors gracefully
-  const userSettingsContent = await FileSystemDisk.readFile(path)
-  return userSettingsContent
-}
-
-export const writeFileInternal = async (getPath, content) => {
-  const path = await getPath()
-  Assert.string(path)
-  if (Platform.platform === PlatformType.Web) {
-    await Command.execute(
-      /* LocalStorage.setText */ 6904,
-      /* key */ path,
-      /* value */ content
-    )
-    return
-  }
-  // TODO handle enoent and other errors gracefully
-  try {
-    await FileSystemDisk.writeFile(path, content)
-  } catch (error) {
-    // TODO error should just have enoent code that could be checked
-
-    // @ts-ignore
-    if (error.message.includes('File not found')) {
-      try {
-        const dirname = Workspace.pathDirName(path)
-        await FileSystemDisk.mkdir(dirname)
-        await FileSystemDisk.writeFile(path, content)
-      } catch (error) {
-        // @ts-ignore
-        error.message = `Failed to write ${path}: ${error.message}`
-        throw error
-      }
-    } else {
-      // @ts-ignore
-      error.message = `Failed to write ${path}: ${error.message}`
-      throw error
-    }
-  }
-}