@lvce-editor/server 0.0.2

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostTextDocument.js

@@ -0,0 +1,39 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as ExtensionHost from './ExtensionHostCore.js'
+import * as ExtensionHostManagement from '../ExtensionHost/ExtensionHostManagement.js'
+
+// TODO instead of sending full document from
+// shared process to renderer-worker to shared process
+// to extension host, extension host could just read file directly
+// or shared process could send extension host file to open
+// after sending file to renderer process
+export const handleEditorCreate = async (editor) => {
+  await ExtensionHostManagement.ensureExtensionHostIsStarted()
+  const text = TextDocument.getText(editor)
+  // TODO should use invoke
+  await ExtensionHost.invoke(
+    /* ExtensionHostTextDocument.syncFull */ 'ExtensionHostTextDocument.syncFull',
+    /* uri */ editor.uri,
+    /* documentId */ editor.id,
+    /* languageId */ editor.languageId,
+    /* text */ text
+  )
+}
+
+export const handleEditorChange = async (editor, changes) => {
+  await ExtensionHostManagement.ensureExtensionHostIsStarted()
+  await ExtensionHost.invoke(
+    /* ExtensionHostTextDocument.syncIncremental */ 'ExtensionHostTextDocument.syncIncremental',
+    /* textDocumentId */ editor.id,
+    /* changes */ changes
+  )
+}
+
+export const handleEditorLanguageChange = async (editor) => {
+  await ExtensionHostManagement.ensureExtensionHostIsStarted()
+  await ExtensionHost.invoke(
+    /* ExtensionHostTextDocument.setLanguageId */ 'ExtensionHostTextDocument.setLanguageId',
+    /* textDocumentId */ editor.id,
+    /* languageId */ editor.languageId
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostTypeDefinition.js

@@ -0,0 +1,13 @@
+import * as ExtensionHost from './ExtensionHostCore.js'
+import * as ExtensionHostManagement from './ExtensionHostManagement.js'
+
+export const executeTypeDefinitionProvider = async (editor, offset) => {
+  await ExtensionHostManagement.activateByEvent(
+    `onTypeDefinition:${editor.languageId}`
+  )
+  return ExtensionHost.invoke(
+    /* ExtensionHost.executeTypeDefinitionProvider */ 'ExtensionHostClosingTag.executeTypeDefinitionProvider',
+    /* textDocumentId */ editor.id,
+    /* offset */ offset
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionHost/shared.js

@@ -0,0 +1,3 @@
+export const languagesHasLoaded = () => {}
+
+export const waitForLanguagesToLoad = () => {}

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -0,0 +1,48 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const install = (id) => {
+  return SharedProcess.invoke(
+    /* ExtensionManagement.install */ 'ExtensionManagement.install',
+    /* id */ id
+  )
+}
+
+export const uninstall = (id) => {
+  return SharedProcess.invoke(
+    /* ExtensionManagement.uninstall */ 'ExtensionManagement.uninstall',
+    /* id */ id
+  )
+}
+
+export const disable = async (id) => {
+  return SharedProcess.invoke(
+    /* ExtensionManagement.disable */ 'ExtensionManagement.disable',
+    /* id */ id
+  )
+}
+
+export const enable = async (id) => {
+  return SharedProcess.invoke(
+    /* ExtensionManagement.enable */ 'ExtensionManagement.enable',
+    /* id */ id
+  )
+}
+
+export const getAllExtensions = async () => {
+  return SharedProcess.invoke(
+    /* ExtensionManagement.getAllExtensions */ 'ExtensionManagement.getAllExtensions'
+  )
+}
+
+const isFulfilled = (result) => {
+  return result.status === 'fulfilled'
+}
+
+const getValue = (result) => {
+  return result.value
+}
+
+export const getWorkingExtensions = async () => {
+  const allExtensions = await getAllExtensions()
+  const fullFilledExtensions = allExtensions.filter(isFulfilled).map(getValue)
+}

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionMarketplace/ExtensionMarketplace.js

@@ -0,0 +1,14 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const getMarketplaceExtensions = async (props) => {
+  const marketplaceUrl = await Platform.getMarketPlaceUrl()
+  const options = {
+    searchParams: props,
+  }
+  return Command.execute(
+    /* Ajax.getJson */ 270,
+    /* url */ `${marketplaceUrl}/api/extensions/search`,
+    /* options */ options
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/ExtensionMeta/ExtensionMeta.js

@@ -0,0 +1,12 @@
+import * as Platform from '../Platform/Platform.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const getExtensions = async () => {
+  if (Platform.getPlatform() === 'web') {
+    return []
+  }
+  const extensions = await SharedProcess.invoke(
+    /* ExtensionManagement.getExtensions */ 'ExtensionManagement.getExtensions'
+  )
+  return extensions
+}

package/static/1914fad/packages/renderer-worker/src/parts/Extensions/Extensions.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Extensions from './Extensions.js'
+
+export const __initialize__ = () => {
+  Command.register(7650, Extensions.openExtensionsFolder)
+  Command.register(7651, Extensions.openCachedExtensionsFolder)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Extensions/Extensions.js

@@ -0,0 +1,12 @@
+import * as Open from '../Open/Open.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const openExtensionsFolder = async () => {
+  const extensionsFolder = await Platform.getExtensionsPath()
+  await Open.openNativeFolder(extensionsFolder)
+}
+
+export const openCachedExtensionsFolder = async () => {
+  const cachedExtensionsFolder = await Platform.getCachedExtensionsPath()
+  await Open.openNativeFolder(cachedExtensionsFolder)
+}

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystem.ipc.js

@@ -0,0 +1,13 @@
+import * as Command from '../Command/Command.js'
+import * as FileSystem from './FileSystem.js'
+
+// TODO who calls this?
+// TODO how to return value?
+
+export const __initialize__ = () => {
+  Command.register(501, FileSystem.readFile)
+  Command.register(502, FileSystem.remove)
+  Command.register(503, FileSystem.readDirWithFileTypes)
+}
+
+// TODO maybe no ipc needed for this module

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystem.js

@@ -0,0 +1,101 @@
+// TODO file system providers should be lazy loaded (maybe)
+
+import * as FileSystemApp from './FileSystemApp.js'
+import * as FileSystemDisk from './FileSystemDisk.js'
+import * as FileSystemGitHub from './FileSystemGitHub.js'
+import * as FileSystemExtensionHost from '../ExtensionHost/ExtensionHostFileSystem.js'
+import * as FileSystemWeb from './FileSystemWeb.js'
+import * as FileSystemData from './FileSystemData.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 'file'
+}
+
+export const state = {
+  fileSystems: Object.create(null),
+}
+
+// TODO extension host should be able to register arbitrary protocols (except app, http, https, file, )
+state.fileSystems['memfs'] = FileSystemExtensionHost
+state.fileSystems['app'] = FileSystemApp
+state.fileSystems['github'] = FileSystemGitHub
+state.fileSystems['web'] = FileSystemWeb
+state.fileSystems['data'] = FileSystemData
+
+const getFileSystem = (protocol) => {
+  return state.fileSystems[protocol] || FileSystemDisk
+}
+
+export const readFile = (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.readFile(protocol, uri)
+}
+
+export const remove = async (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.remove(protocol, uri)
+}
+
+export const rename = async (oldUri, newUri) => {
+  const protocol = getProtocol(oldUri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.rename(protocol, oldUri, newUri)
+}
+
+export const mkdir = async (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.mkdir(protocol, uri)
+}
+
+export const writeFile = async (uri, content) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.writeFile(protocol, uri, content)
+}
+
+export const readDirWithFileTypes = (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.readDirWithFileTypes(protocol, uri)
+}
+
+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 fileSystem = getFileSystem(protocol)
+  return fileSystem.getBlobUrl(protocol, uri)
+}
+
+export const copy = (source, target) => {
+  // TODO what if it is not the same file system?
+  const protocol = getProtocol(source)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.copy(protocol, source, target)
+}
+
+export const getPathSeparator = (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.getPathSeparator(protocol)
+}

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystemApp.js

@@ -0,0 +1,124 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as FileSystemDisk from './FileSystemDisk.js'
+import * as Workspace from '../Workspace/Workspace.js'
+import * as Assert from '../Assert/Assert.js'
+
+const readFileInternal = async (getPath) => {
+  const path = await getPath()
+  Assert.string(path)
+  if (Platform.getPlatform() === 'web') {
+    const settingsJsonContent = await Command.execute(
+      /* LocalStorage.getText */ 6903,
+      /* key */ path
+    )
+    if (settingsJsonContent) {
+      return settingsJsonContent
+    }
+    const assetDir = Platform.getAssetDir()
+    const url = `${assetDir}/config/defaultSettings.json`
+    return Command.execute(/* Ajax.getText */ 271, /* url */ url)
+  }
+  // TODO handle enoent and other errors gracefully
+  const userSettingsContent = await FileSystemDisk.readFile('file', path)
+  return userSettingsContent
+}
+
+// TODO ask preferences module to do this
+const readFileSettingsJson = async () => {
+  return readFileInternal(Platform.getUserSettingsPath)
+}
+
+const readFileRecentlyOpenedJson = async () => {
+  return readFileInternal(Platform.getRecentlyOpenedPath)
+}
+
+export const readFile = (protocol, path) => {
+  switch (path) {
+    case 'app://startup-performance':
+      return Command.execute(/* Developer.getStartupPerformanceContent */ 820)
+    case 'app://memory-usage':
+      return Command.execute(/* Developer.getMemoryUsageContent */ 821)
+    case 'app://settings.json':
+      return readFileSettingsJson()
+    case 'app://recently-opened.json':
+      return readFileRecentlyOpenedJson()
+    default:
+      return ''
+  }
+}
+
+const writeFileInternal = async (getPath, content) => {
+  const path = await getPath()
+  Assert.string(path)
+  if (Platform.getPlatform() === 'web') {
+    await Command.execute(
+      /* LocalStorage.setText */ 6904,
+      /* key */ path,
+      /* value */ content
+    )
+    return
+  }
+  // TODO handle enoent and other errors gracefully
+  try {
+    await FileSystemDisk.writeFile('file', path, content)
+  } catch (error) {
+    // TODO error should just have enoent code that could be checked
+
+    if (error.message.includes('ENOENT')) {
+      try {
+        const dirname = Workspace.pathDirName(path)
+        await FileSystemDisk.mkdir('file', dirname)
+        await FileSystemDisk.writeFile('file', path, content)
+      } catch (error) {
+        error.message = `Failed to write ${path}: ${error.message}`
+        throw error
+      }
+    } else {
+      error.message = `Failed to write ${path}: ${error.message}`
+      throw error
+    }
+  }
+}
+
+const writeFileSettingsJson = (content) => {
+  return writeFileInternal(Platform.getUserSettingsPath, content)
+}
+
+const writeFileRecentlyOpenedJson = (content) => {
+  return writeFileInternal(Platform.getRecentlyOpenedPath, content)
+}
+
+export const writeFile = async (protocol, path, content) => {
+  switch (path) {
+    case 'app://settings.json':
+      // TODO in web write to local storage, in electron write to config file
+      return writeFileSettingsJson(content)
+    case 'app://startup-performance':
+      break
+    case 'app://recently-opened.json':
+      return writeFileRecentlyOpenedJson(content)
+    default:
+      break
+  }
+}
+
+export const readDirWithFileTypes = () => {
+  return []
+}
+
+export const rename = async (protocol, oldUri, newUri) => {
+  throw new Error('not allowed')
+}
+
+export const remove = async (protocol, path) => {
+  throw new Error('not allowed')
+}
+
+export const mkdir = async (protocol, path) => {
+  throw new Error('not allowed')
+}
+
+export const getPathSeparator = (protocol) => {
+  return '/'
+}

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystemData.js

@@ -0,0 +1,37 @@
+export const copy = (protocol, source, target) => {
+  throw new Error('not implemented')
+}
+
+export const readFile = (protocol, path) => {
+  return path.slice(protocol.length + 3)
+}
+
+export const remove = (protocol, path) => {
+  throw new Error('not implemented')
+}
+
+export const rename = (protocol, oldUri, newUri) => {
+  throw new Error('not implemented')
+}
+
+export const mkdir = (protocol, path) => {
+  throw new Error('not implemented')
+}
+
+export const writeFile = async (protocol, path, content) => {
+  throw new Error('not implemented')
+}
+
+export const ensureFile = async () => {}
+
+export const readDirWithFileTypes = (protocol, path) => {
+  throw new Error('not implemented')
+}
+
+export const getBlobUrl = (protocol, path) => {
+  throw new Error('not implemented')
+}
+
+export const getPathSeparator = (protocol) => {
+  throw new Error('not implemented')
+}

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystemDisk.js

@@ -0,0 +1,69 @@
+import * as Platform from '../Platform/Platform.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const copy = (protocol, source, target) => {
+  return SharedProcess.invoke(
+    /* FileSystem.copy */ 'Filesystem.copy',
+    /* source */ source,
+    /* target */ target
+  )
+}
+
+export const readFile = (protocol, path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.readFile */ 'FileSystem.readFile',
+    /* path */ path
+  )
+}
+
+export const remove = (protocol, path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.remove */ 'FileSystem.remove',
+    /* path */ path
+  )
+}
+
+export const rename = (protocol, oldUri, newUri) => {
+  return SharedProcess.invoke(
+    /* FileSystem.rename */ 'FileSystem.rename',
+    /* oldPath */ oldUri,
+    /* newPath */ newUri
+  )
+}
+
+export const mkdir = (protocol, path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.mkdir */ 'FileSystem.mkdir',
+    /* path */ path
+  )
+}
+
+export const writeFile = async (protocol, path, content) => {
+  await SharedProcess.invoke(
+    /* FileSystem.writeFile */ 'FileSystem.writeFile',
+    /* path */ path,
+    /* content */ content
+  )
+}
+
+export const ensureFile = async () => {}
+
+export const readDirWithFileTypes = (protocol, path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.readDirWithFileTypes */ 'FileSystem.readDirWithFileTypes',
+    /* path */ path
+  )
+}
+
+export const getBlobUrl = (protocol, path) => {
+  return `/remote/${path}`
+}
+
+export const getPathSeparator = (protocol) => {
+  if (Platform.getPlatform() === 'web') {
+    return '/'
+  }
+  return SharedProcess.invoke(
+    /* FileSystem.getPathSeparator */ 'FileSystem.getPathSeparator'
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/FileSystem/FileSystemGitHub.js

@@ -0,0 +1,77 @@
+// based on https://github.com/conwnet/github1s/blob/master/extensions/github1s/src/interfaces/github-api-rest.ts
+
+import * as GitHubRestApi from '../GitHubRestApi/GitHubRestApi.js'
+import * as Command from '../Command/Command.js'
+
+export const state = {
+  cache: Object.create(null),
+}
+
+const getGitHubFile = async (uri) => {
+  const relativeUri = uri.slice('github://'.length)
+  const parts = relativeUri.split('/')
+  const [owner, repo, ...rest] = parts
+  const relativePath = rest.join('/') // TODO many times split/join a bit unnecessary
+  const githubFile = await GitHubRestApi.readFile(owner, repo, relativePath)
+  // TODO what if it is not a file but a folder?
+  return githubFile
+}
+
+export const readFile = async (protocol, path) => {
+  const githubFile = await getGitHubFile(path)
+  if (githubFile.encoding !== 'base64') {
+    throw new Error('unsupported encoding')
+  }
+  return Command.execute(
+    /* Base64.decode */ 7890,
+    /* encoded */ githubFile.content
+  )
+}
+
+const getType = (githubType) => {
+  switch (githubType) {
+    case 'tree':
+      return 'folder'
+    case 'blob':
+      return 'file'
+    default:
+      return 'unknown'
+  }
+}
+
+const toDirent = (githubDirent) => {
+  return {
+    name: githubDirent.path,
+    type: getType(githubDirent.type),
+  }
+}
+
+const toDirents = (githubResponse) => {
+  return githubResponse.tree.map(toDirent)
+}
+
+export const readDirWithFileTypes = async (protocol, path) => {
+  const relativeUri = path.slice('github://'.length)
+  const parts = relativeUri.split('/')
+  const [owner, repo, ...rest] = parts
+  const relativePath = '/' + rest.join('/') // TODO many times split/join a bit unnecessary
+  // TODO handle reading real directory
+  const githubDirents = await GitHubRestApi.readGitHubDirectory(
+    owner,
+    repo,
+    'HEAD',
+    relativePath
+  )
+  state.cache[relativeUri] = githubDirents
+  const dirents = toDirents(githubDirents)
+  return dirents
+}
+
+export const getBlobUrl = async (protocol, path) => {
+  const githubFile = await getGitHubFile(path)
+  return githubFile.download_url
+}
+
+export const getPathSeparator = () => {
+  return '/'
+}