@lvce-editor/server 0.12.0 → 0.13.0

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

@@ -0,0 +1,78 @@
+import * as Callback from '../Callback/Callback.js'
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+const isResultMessage = (message) => {
+  return 'result' in message
+}
+
+const isErrorMessage = (message) => {
+  return 'error' in message
+}
+
+const handleMessageMethod = async (message, event) => {
+  if (message.method === 'ElectronMessagePort.create') {
+    const IpcParentWithElectron = await import('../IpcParentWithElectron/IpcParentWithElectron.js')
+    const ipc = await IpcParentWithElectron.create({
+      type: 'extension-host-helper-process',
+    })
+    event.target.postMessage(
+      {
+        jsonrpc: JsonRpcVersion.Two,
+        id: message.id,
+        result: ipc._port,
+      },
+      [ipc._port]
+    )
+  } else if (message.method === 'Test.executeMockExecFunction') {
+    const response = await GetResponse.getResponse(message)
+    event.target.send(response)
+  } else if (message.method === 'get-port') {
+    const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = await import(
+      '../IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug/IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug.js'
+    )
+    const port = await IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug.create({
+      url: message.params[0],
+      name: message.params[1],
+    })
+    event.target.send(
+      {
+        jsonrpc: JsonRpcVersion.Two,
+        id: message.id,
+        result: port,
+      },
+      [port]
+    )
+  } else {
+    await GlobalEventBus.emitEvent(message.method, ...message.params)
+  }
+}
+
+const handleMessage = async (message, event) => {
+  if (message.id) {
+    if (isResultMessage(message) || isErrorMessage(message)) {
+      Callback.resolve(message.id, message)
+    } else if ('method' in message) {
+      handleMessageMethod(message, event)
+    } else {
+      throw new JsonRpcError('unexpected message type')
+    }
+  } else if (message.method) {
+    await GlobalEventBus.emitEvent(message.method, ...message.params)
+  } else {
+    throw new JsonRpcError('unexpected message type')
+  }
+}
+
+export const listen = (ipc) => {
+  // TODO maybe pass handleMessage as parameter to make code more functional
+  ipc.onmessage = handleMessage
+  return {
+    invoke(method, ...params) {
+      return JsonRpc.invoke(ipc, method, ...params)
+    },
+  }
+}

package/static/c808931/packages/renderer-worker/src/parts/FileNotFoundError/FileNotFoundError.js

@@ -0,0 +1,9 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export class FileNotFoundError extends Error {
+  constructor(path) {
+    super(`File not found '${path}'`)
+    this.code = ErrorCodes.ENOENT
+    this.name = 'FileNotFoundError'
+  }
+}

package/static/c808931/packages/renderer-worker/src/parts/FileSearchCache/FileSearchCache.js

@@ -0,0 +1,30 @@
+import * as CacheStorage from '../CacheStorage/CacheStorage.js'
+import { VError } from '../VError/VError.js'
+
+const normalizeCacheKey = (cacheKey) => {
+  if (cacheKey.startsWith('/')) {
+    return cacheKey
+  }
+  return `/${cacheKey}`
+}
+
+const cacheName = 'file-search-cache'
+
+export const get = async (cacheKey) => {
+  try {
+    const normalizedCacheKey = normalizeCacheKey(cacheKey)
+    const text = await CacheStorage.getTextFromCache(normalizedCacheKey)
+    return text
+  } catch (error) {
+    throw new VError(error, `Failed to get value from file search cache`)
+  }
+}
+
+export const set = async (cacheKey, value) => {
+  try {
+    const normalizedCacheKey = normalizeCacheKey(cacheKey)
+    await CacheStorage.setText(normalizedCacheKey, value, 'text/plain')
+  } catch (error) {
+    throw new VError(error, `Failed to put value into file search cache`)
+  }
+}

package/static/c808931/packages/renderer-worker/src/parts/FileSystem/FileSystemHtml.js

@@ -0,0 +1,152 @@
+import * as BrowserErrorTypes from '../BrowserErrorTypes/BrowserErrorTypes.js'
+import * as FileHandleEditMode from '../FileHandleEditMode/FileHandleEditMode.js'
+import * as FileHandlePermissionType from '../FileHandlePermissionType/FileHandlePermissionType.js'
+import * as FileHandleTypeMap from '../FileHandleTypeMap/FileHandleTypeMap.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
+import * as FileSystemDirectoryHandle from '../FileSystemDirectoryHandle/FileSystemDirectoryHandle.js'
+import * as FileSystemFileHandle from '../FileSystemFileHandle/FileSystemFileHandle.js'
+import * as FileSytemHandlePermission from '../FileSystemHandlePermission/FileSystemHandlePermission.js'
+import * as Path from '../Path/Path.js'
+import * as PersistentFileHandle from '../PersistentFileHandle/PersistentFileHandle.js'
+import { VError } from '../VError/VError.js'
+
+const pathSeparator = '/'
+
+const getDirent = (handle) => {
+  const { name, kind } = handle
+  const type = FileHandleTypeMap.getDirentType(kind)
+  return {
+    name,
+    type,
+  }
+}
+
+export const getDirents = (handles) => {
+  const dirents = handles.map(getDirent)
+  return dirents
+}
+
+const getChildHandlesFallbackPrompt = async (handle) => {
+  // TODO cannot prompt without user activation, else error occurs
+  // maybe need to show
+  const permissionTypeNow = await FileSytemHandlePermission.requestPermission(handle, {
+    mode: FileHandleEditMode.ReadWrite,
+  })
+  switch (permissionTypeNow) {
+    case FileHandlePermissionType.Granted:
+      return FileSystemDirectoryHandle.getChildHandles(handle)
+    case FileHandlePermissionType.Prompt:
+    case FileHandlePermissionType.Denied:
+      // TODO maybe throw error in this case
+      return []
+    default:
+      return []
+  }
+}
+
+const getChildHandlesFallback = async (handle) => {
+  const permissionType = await FileSytemHandlePermission.queryPermission(handle, {
+    mode: FileHandleEditMode.ReadWrite,
+  })
+  switch (permissionType) {
+    case FileHandlePermissionType.Granted:
+      throw new VError(`invalid state`)
+    case FileHandlePermissionType.Prompt:
+      return await getChildHandlesFallbackPrompt(handle)
+    case FileHandlePermissionType.Denied:
+      return []
+    default:
+      return []
+  }
+}
+
+const getChildHandles = async (handle) => {
+  try {
+    return await FileSystemDirectoryHandle.getChildHandles(handle)
+  } catch (error) {
+    if (BrowserErrorTypes.isNotAllowedError(error)) {
+      return getChildHandlesFallback(handle)
+    }
+    throw new VError(error, `failed to get child handles`)
+  }
+}
+
+export const readDirWithFileTypes = async (uri) => {
+  try {
+    // TODO convert uri to file handle path, get file handle from indexeddb
+    // if file handle does not exist, throw error
+    const handle = await PersistentFileHandle.getHandle(uri)
+    if (!handle) {
+      throw new Error(`File system handle not found for ${uri}`)
+    }
+    const childHandles = await getChildHandles(handle)
+    await PersistentFileHandle.addHandles(uri, childHandles)
+    const dirents = getDirents(childHandles)
+    return dirents
+  } catch (error) {
+    throw new VError(error, `failed to read directory`)
+  }
+}
+
+const getDirectoryHandle = async (uri) => {
+  const handle = await PersistentFileHandle.getHandle(uri)
+  if (handle) {
+    return handle
+  }
+  const dirname = Path.dirname(pathSeparator, uri)
+  if (uri === dirname) {
+    return undefined
+  }
+  return getDirectoryHandle(dirname)
+}
+
+const getFileHandle = async (uri) => {
+  const handle = await PersistentFileHandle.getHandle(uri)
+  if (handle) {
+    return handle
+  }
+  const dirname = Path.dirname(pathSeparator, uri)
+  const parentHandle = await getDirectoryHandle(dirname)
+  if (!parentHandle) {
+    return undefined
+  }
+  const baseName = Path.getBaseName(pathSeparator, uri)
+  const fileHandle = await FileSystemDirectoryHandle.getFileHandle(parentHandle, baseName)
+  return fileHandle
+}
+
+export const readFile = async (uri) => {
+  try {
+    const handle = await getFileHandle(uri)
+    if (!handle) {
+      throw new VError(`File not found ${uri}`)
+    }
+    const file = await FileSystemFileHandle.getFile(handle)
+    const text = await file.text()
+    return text
+  } catch (error) {
+    if (BrowserErrorTypes.isNotFoundError(error)) {
+      throw new FileNotFoundError(uri)
+    }
+    throw new VError(error, `Failed to read file`)
+  }
+}
+
+export const writeFile = async (uri, content) => {
+  try {
+    const handle = await getFileHandle(uri)
+    if (!handle) {
+      throw new VError(`File not found ${uri}`)
+    }
+    await FileSystemFileHandle.write(handle, content)
+  } catch (error) {
+    throw new VError(error, `Failed to save file`)
+  }
+}
+
+export const getPathSeparator = () => {
+  return pathSeparator
+}
+
+// not possible because FileHandle permissions are on preserved on reload
+export const canBeRestored = false

package/static/c808931/packages/renderer-worker/src/parts/FileSystemDirectoryHandle/FileSystemDirectoryHandle.js

@@ -0,0 +1,24 @@
+import * as Arrays from '../Arrays/Arrays.js'
+import * as Assert from '../Assert/Assert.js'
+
+/**
+ *
+ * @param {FileSystemDirectoryHandle} handle
+ * @returns {Promise<FileSystemHandle[]>}
+ */
+export const getChildHandles = async (handle) => {
+  Assert.object(handle)
+  // @ts-ignore
+  const handles = await Arrays.fromAsync(handle.values())
+  return handles
+}
+
+/**
+ *
+ * @param {FileSystemDirectoryHandle} handle
+ * @param {string} name
+ * @returns
+ */
+export const getFileHandle = (handle, name) => {
+  return handle.getFileHandle(name)
+}

package/static/c808931/packages/renderer-worker/src/parts/FileSystemFileHandle/FileSystemFileHandle.js

@@ -0,0 +1,45 @@
+import * as HtmlFile from '../HtmlFile/HtmlFile.js'
+
+/**
+ *
+ * @param {FileSystemFileHandle} handle
+ * @returns
+ */
+export const getFile = (handle) => {
+  return handle.getFile()
+}
+
+/**
+ *
+ * @param {FileSystemFileHandle} handle
+ * @returns
+ */
+export const getBinaryString = async (handle) => {
+  const file = await getFile(handle)
+  const text = await HtmlFile.getBinaryString(file)
+  return text
+}
+
+/**
+ *
+ * @param {FileSystemFileHandle} handle
+ * @param {string} content
+ */
+export const write = async (handle, content) => {
+  // @ts-ignore
+  const writable = await handle.createWritable()
+  await writable.write(content)
+  await writable.close()
+}
+
+/**
+ *
+ * @param {FileSystemFileHandle} handle
+ * @param {Response} response
+ */
+export const writeResponse = async (handle, response) => {
+  // @ts-ignore
+  const writable = await handle.createWritable()
+  // @ts-ignore
+  await response.body.pipeTo(writable)
+}

package/static/c808931/packages/renderer-worker/src/parts/FilterQuickPickItems/FilterQuickPickItems.js

@@ -0,0 +1,49 @@
+import * as Assert from '../Assert/Assert.js'
+import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
+
+const filterPicks = (state, picks, exclude, value, provider) => {
+  // TODO every pick should have label
+  const filterPick = (pick) => {
+    const filterValue = provider.getPickFilterValue(pick)
+    Assert.string(filterValue)
+    if (exclude.has(filterValue)) {
+      return false
+    }
+    if (!filterValue && !state.warned.includes(JSON.stringify(pick))) {
+      console.warn('[QuickPick] item has missing label', pick)
+      state.warned.push(JSON.stringify(pick))
+      return false
+    }
+    const labelMatch = FuzzySearch.fuzzySearch(value, filterValue)
+    if (labelMatch) {
+      return labelMatch
+    }
+    // TODO also filtering for aliases might be expensive
+    // TODO maybe only filter for aliases if prefix is longer than 4-5 characters
+    // otherwise both will be found anywayf
+    // e.g. "Relo" matches  "Window Reload"  and "Reload Window"
+    // But "Reload Win" only matches "Reload Window"
+    if (pick.aliases) {
+      for (const alias of pick.aliases) {
+        if (FuzzySearch.fuzzySearch(value, alias)) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+  const items = picks.filter(filterPick)
+  return items
+}
+
+export const getFilteredItems = (state, picks, recentPickIds, filterValue, provider) => {
+  Assert.object(state)
+  Assert.array(picks)
+  Assert.string(filterValue)
+  const items = filterPicks(state, picks, recentPickIds, filterValue, provider)
+  return items
+  // TODO avoid mutation
+  // state.items = items
+  // const slicedPicks = slicePicks(items)
+  // return toDisplayPicks(slicedPicks)
+}

package/static/c808931/packages/renderer-worker/src/parts/FirstWorkerEventType/FirstWorkerEventType.js

@@ -0,0 +1,3 @@
+export const Message = 'message'
+
+export const Error = 'error'

package/static/c808931/packages/renderer-worker/src/parts/GetDecorationClassName/GetDecorationClassName.js

@@ -0,0 +1,53 @@
+import * as DecorationClassName from '../DecorationClassName/DecorationClassName.js'
+import * as DecorationType from '../DecorationType/DecorationType.js'
+
+export const getDecorationClassName = (type) => {
+  switch (type) {
+    case DecorationType.Link:
+      return DecorationClassName.Link
+    case DecorationType.Ts2816:
+    case DecorationType.Ts2817:
+    case DecorationType.Ts2824:
+    case DecorationType.Ts2825:
+    case DecorationType.Ts2856:
+    case DecorationType.Ts2857:
+    case DecorationType.Ts3072:
+    case DecorationType.Ts3073:
+    case DecorationType.Ts3077:
+    case DecorationType.Ts3088:
+      return DecorationClassName.Function
+    case DecorationType.Ts1792:
+    case DecorationType.Ts1793:
+      return DecorationClassName.Parameter
+    case DecorationType.Ts512:
+    case DecorationType.Ts513:
+    case DecorationType.Ts769:
+    case DecorationType.Ts1024:
+    case DecorationType.Ts1536:
+    case DecorationType.Ts1537:
+    case DecorationType.Ts1544:
+    case DecorationType.Ts1545:
+      return DecorationClassName.Type
+    case DecorationType.Ts2048:
+    case DecorationType.Ts2049:
+    case DecorationType.Ts2056:
+    case DecorationType.Ts2057:
+    case DecorationType.Ts2064:
+    case DecorationType.Ts2080:
+    case DecorationType.Ts2081:
+    case DecorationType.Ts2088:
+    case DecorationType.Ts2089:
+    case DecorationType.Ts2313:
+    case DecorationType.Ts2560:
+    case DecorationType.Ts2561:
+    case DecorationType.Ts2569:
+    case DecorationType.Ts2584:
+      return DecorationClassName.VariableName
+    case DecorationType.Ts256:
+    case DecorationType.Ts257:
+    case DecorationType.Ts272:
+      return DecorationClassName.Class
+    default:
+      return `Unknown-${type}`
+  }
+}

package/static/c808931/packages/renderer-worker/src/parts/GetErrorConstructor/GetErrorConstructor.js

@@ -0,0 +1,28 @@
+import * as ErrorType from '../ErrorType/ErrorType.js'
+
+export const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case ErrorType.DomException:
+        return DOMException
+      case ErrorType.TypeError:
+        return TypeError
+      case ErrorType.SyntaxError:
+        return SyntaxError
+      case ErrorType.ReferenceError:
+        return ReferenceError
+      default:
+        return Error
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError
+  }
+  return Error
+}

package/static/c808931/packages/renderer-worker/src/parts/GetFirstWorkerEvent/GetFirstWorkerEvent.js

@@ -0,0 +1,21 @@
+import * as FirstWorkerEventType from '../FirstWorkerEventType/FirstWorkerEventType.js'
+
+export const getFirstWorkerEvent = async (worker) => {
+  const { type, event } = await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      worker.onmessage = null
+      worker.onerror = null
+    }
+    const handleFirstMessage = (event) => {
+      cleanup()
+      resolve({ type: FirstWorkerEventType.Message, event })
+    }
+    const handleFirstError = (event) => {
+      cleanup()
+      resolve({ type: FirstWorkerEventType.Error, event })
+    }
+    worker.onmessage = handleFirstMessage
+    worker.onerror = handleFirstError
+  })
+  return { type, event }
+}