@lvce-editor/server 0.13.0 → 0.14.0

package/static/5a94137/packages/renderer-worker/src/parts/IconTheme/IconTheme.js

@@ -0,0 +1,224 @@
+import * as Command from '../Command/Command.js'
+import * as DefaultIcon from '../DefaultIcon/DefaultIcon.js'
+import * as DirentType from '../DirentType/DirentType.js'
+import * as ExtensionMeta from '../ExtensionMeta/ExtensionMeta.js'
+import * as Languages from '../Languages/Languages.js'
+import * as Logger from '../Logger/Logger.js'
+import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+import * as Preferences from '../Preferences/Preferences.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import { VError } from '../VError/VError.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as Workspace from '../Workspace/Workspace.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SharedProcessCommandType from '../SharedProcessCommandType/SharedProcessCommandType.js'
+
+export const state = {
+  seenFiles: [],
+  seenFolders: [],
+  hasWarned: [],
+  /**
+   * @type{any}
+   */
+  iconTheme: undefined,
+}
+
+const getIconThemeUrl = (iconThemeId) => {
+  return `/extensions/builtin.${iconThemeId}/icon-theme.json`
+}
+
+const getIconThemeJson = async (iconThemeId) => {
+  if (Platform.platform === PlatformType.Web) {
+    const url = getIconThemeUrl(iconThemeId)
+    const json = await Command.execute(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
+    const assetDir = Platform.getAssetDir()
+    return {
+      json,
+      extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`,
+    }
+  }
+  for (const webExtension of ExtensionMeta.state.webExtensions) {
+    if (webExtension.iconThemes) {
+      for (const iconTheme of webExtension.iconThemes) {
+        // TODO handle error when icon theme path is not of type string
+        const iconThemeUrl = `${webExtension.path}/${iconTheme.path}`
+        const json = await Command.execute('Ajax.getJson', iconThemeUrl)
+        return {
+          json,
+          extensionPath: webExtension.path,
+        }
+      }
+    }
+  }
+  return SharedProcess.invoke(SharedProcessCommandType.ExtensionHostGetIconThemeJson, /* iconThemeId */ iconThemeId)
+}
+
+const getExtension = (file) => {
+  return file.slice(file.indexOf('.') + 1).toLowerCase()
+}
+
+export const getFileIcon = (file) => {
+  const { iconTheme } = state
+  const fileNameLower = file.name.toLowerCase()
+  if (!iconTheme) {
+    return ''
+  }
+  if (iconTheme.fileNames) {
+    const fileNameIcon = iconTheme.fileNames[fileNameLower]
+    if (fileNameIcon) {
+      return fileNameIcon
+    }
+  }
+  if (iconTheme.fileExtensions) {
+    let index = -1
+    while ((index = fileNameLower.indexOf('.', index + 1)) !== -1) {
+      const shorterExtension = fileNameLower.slice(index + 1)
+      const extensionIcon = iconTheme.fileExtensions[shorterExtension]
+      if (extensionIcon) {
+        return extensionIcon
+      }
+    }
+  }
+  if (iconTheme.languageIds) {
+    const languageId = Languages.getLanguageId(fileNameLower)
+    const languageIcon = iconTheme.languageIds[languageId]
+    if (languageId === 'jsx' && fileNameLower.endsWith('.js')) {
+      const alternativeFileIcon = iconTheme.languageIds['javascript']
+      if (alternativeFileIcon) {
+        return alternativeFileIcon
+      }
+    }
+    if (languageIcon) {
+      return languageIcon
+    }
+  }
+  return DefaultIcon.File
+}
+
+export const getFolderIcon = (folder) => {
+  const iconTheme = state.iconTheme
+  // @ts-ignore
+  if (!iconTheme || !iconTheme.folderNames) {
+    return ''
+  }
+  const folderNameLower = folder.name.toLowerCase()
+  // @ts-ignore
+  const folderIcon = iconTheme.folderNames[folderNameLower]
+  if (folderIcon) {
+    return folderIcon
+  }
+  return DefaultIcon.Folder
+}
+
+const getFolderIconExpanded = (folder) => {
+  const iconTheme = state.iconTheme
+  if (!iconTheme) {
+    return ''
+  }
+  // @ts-ignore
+  if (!iconTheme.folderNamesExpanded) {
+    return DefaultIcon.FolderOpen
+  }
+  // @ts-ignore
+  const folderName = iconTheme.folderNamesExpanded[folder.name.toLowerCase()]
+  if (folderName) {
+    return folderName
+  }
+  return DefaultIcon.FolderOpen
+}
+
+export const getIcon = (dirent) => {
+  switch (dirent.type) {
+    case DirentType.File:
+    case DirentType.SymLinkFile:
+      return getFileIcon(dirent)
+    case DirentType.Directory:
+    case DirentType.SymLinkFolder:
+      return getFolderIcon(dirent)
+    case DirentType.DirectoryExpanded:
+      return getFolderIconExpanded(dirent)
+    case DirentType.Symlink:
+    case DirentType.CharacterDevice:
+    case DirentType.BlockDevice:
+    case DirentType.Socket:
+      return DefaultIcon.File
+    default:
+      Logger.warn(`unsupported type ${dirent.type}`)
+      return DefaultIcon.None
+  }
+}
+
+const getBackgroundUrl = (extensionPath, value) => {
+  if (Platform.platform === PlatformType.Web) {
+    return `${extensionPath}${value}`
+  }
+  if (extensionPath.startsWith('http://')) {
+    return `${extensionPath}${value}`
+  }
+  // TODO what if the file in on linux and includes a backslash?
+  if (extensionPath.includes('\\')) {
+    const extensionUri = extensionPath.replaceAll('\\', '/')
+    return `/remote/${extensionUri}/${value}`
+  }
+  return `/remote${extensionPath}/${value}`
+}
+
+const getIconThemeCss2 = (iconTheme) => {
+  const rules = []
+  const iconDefinitions = iconTheme.json.iconDefinitions
+  const extensionPath = iconTheme.extensionPath
+  for (const [key, value] of Object.entries(iconDefinitions)) {
+    const backgroundUrl = getBackgroundUrl(extensionPath, value)
+    rules.push(`.FileIcon${key} { background-image: url(${backgroundUrl}) }`)
+  }
+  const rulesCss = JoinLines.joinLines(rules)
+  return rulesCss
+}
+
+export const setIconTheme = async (iconThemeId) => {
+  try {
+    const iconTheme = await getIconThemeJson(iconThemeId)
+    state.iconTheme = iconTheme.json
+    state.extensionPath = iconTheme.extensionPath
+    const iconThemeCss = getIconThemeCss2(iconTheme)
+
+    const instances = ViewletStates.getAllInstances()
+    // TODO have one recalculate style and one paint
+    for (const [key, value] of Object.entries(instances)) {
+      const { factory, state } = value
+      if (factory.handleIconThemeChange) {
+        const newState = factory.handleIconThemeChange(state)
+        await Viewlet.setState(factory.name, newState)
+      }
+    }
+    await RendererProcess.invoke(/* Css.setInlineStyle */ 'Css.setInlineStyle', /* id */ 'ContributedIconTheme', /* css */ iconThemeCss)
+  } catch (error) {
+    if (Workspace.isTest()) {
+      // ignore
+    } else {
+      console.error(new VError(error, `Failed to load icon theme`))
+    }
+  }
+}
+
+export const hydrate = async () => {
+  // TODO icon theme css can be really large (3000+ lines)
+  // and slow down recalculate style by 5x (e.g. rendering text in editor: 1.42ms normal, 7.42ms with icon theme)
+  // icon theme should not slow down editor.
+  // maybe set applied css only to actual used icons
+  // for example, when a js file is in explorer, only generate the css for the js icon
+  // that way there would be much less rules, but when a new file type appears (which should not happen often)
+  // the css must be recalculated again
+  // const iconThemeCss = await getIconThemeCss()
+  // await RendererProcess.invoke(
+  //   /* Css.setInlineStyle */ 4551,
+  //   /* id */ 'ContributedIconTheme',
+  //   /* css */ iconThemeCss
+  // )
+
+  const iconThemeId = Preferences.get('icon-theme') || 'vscode-icons'
+  await setIconTheme(iconThemeId)
+}

package/static/5a94137/packages/renderer-worker/src/parts/Id/Id.js

@@ -0,0 +1,7 @@
+export const state = {
+  id: 0,
+}
+
+export const create = () => {
+  return ++state.id
+}

package/static/5a94137/packages/renderer-worker/src/parts/ImportScript/ImportScript.js

@@ -0,0 +1,10 @@
+import * as TryToGetactualImportErrorMessage from '../TryToGetActualImportErrorMessage/TryToGetActualImportErrorMessage.js'
+
+export const importScript = async (url) => {
+  try {
+    return await import(url)
+  } catch (error) {
+    const actualErrorMessage = await TryToGetactualImportErrorMessage.tryToGetActualImportErrorMessage(url, error)
+    throw new Error(actualErrorMessage)
+  }
+}

package/static/5a94137/packages/renderer-worker/src/parts/InputDeleteCharacterLeft/InputDeleteCharacterLeft.js

@@ -0,0 +1,16 @@
+import * as IsEmptyString from '../IsEmptyString/IsEmptyString.js'
+
+export const deleteCharacterLeft = (value, cursorOffset) => {
+  if (IsEmptyString.isEmptyString(value)) {
+    return {
+      newValue: value,
+      newCursorOffset: cursorOffset,
+    }
+  }
+  const newValue = value.slice(0, -1)
+  const newCursorOffset = newValue.length
+  return {
+    newValue,
+    newCursorOffset,
+  }
+}

package/static/5a94137/packages/renderer-worker/src/parts/InstallExtension/InstallExtension.js

@@ -0,0 +1,6 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as SharedProcessCommandType from '../SharedProcessCommandType/SharedProcessCommandType.js'
+
+export const install = (id) => {
+  return SharedProcess.invoke(SharedProcessCommandType.InstallExtensionInstallExtension, /* id */ id)
+}

package/static/5a94137/packages/renderer-worker/src/parts/IpcParentWithElectron/IpcParentWithElectron.js

@@ -0,0 +1,53 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Callback from '../Callback/Callback.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as RendererProcessIpcParentType from '../RendererProcessIpcParentType/RendererProcessIpcParentType.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const create = async (options) => {
+  const type = options.type
+  Assert.string(type)
+  const { id, promise } = Callback.registerPromise()
+  RendererProcess.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method: 'get-port',
+    _id: id,
+    params: [
+      {
+        method: RendererProcessIpcParentType.Electron,
+        type,
+      },
+    ],
+  })
+  const response = await promise
+  const port = response.result
+  return port
+}
+
+export const wrap = (port) => {
+  let handleMessage
+  return {
+    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) {
+            listener(event.data)
+          } else {
+            listener(event)
+          }
+        }
+      } else {
+        handleMessage = null
+      }
+      port.onmessage = handleMessage
+    },
+    send(message) {
+      port.postMessage(message)
+    },
+    _port: port,
+  }
+}

package/static/5a94137/packages/renderer-worker/src/parts/IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug/IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug.js

@@ -0,0 +1,61 @@
+import * as Callback from '../Callback/Callback.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as RendererProcessIpcParentType from '../RendererProcessIpcParentType/RendererProcessIpcParentType.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const create = async ({ url, name }) => {
+  const { id, promise } = Callback.registerPromise()
+  RendererProcess.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method: 'get-port',
+    _id: id,
+    params: [
+      {
+        method: RendererProcessIpcParentType.ModuleWorkerWithMessagePort,
+        url,
+        name,
+      },
+    ],
+  })
+  const response = await promise
+  const port = response.result
+  return port
+}
+
+export const wrap = (port) => {
+  let handleMessage
+  const fakeEvent = {
+    target: {
+      send(message, transfer) {
+        port.postMessage(message, transfer)
+      },
+    },
+  }
+  return {
+    get onmessage() {
+      return port.onmessage
+    },
+    set onmessage(listener) {
+      if (listener) {
+        handleMessage = (event) => {
+          // TODO why are some events not instance of message event?
+          if (event instanceof MessageEvent) {
+            const message = event.data
+            listener(message, fakeEvent)
+          } else {
+            listener(event)
+          }
+        }
+      } else {
+        handleMessage = null
+      }
+      port.onmessage = handleMessage
+    },
+    send(message) {
+      port.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      port.postMessage(message, transfer)
+    },
+  }
+}

package/static/5a94137/packages/renderer-worker/src/parts/IsAllAutoClosingPairDelete/IsAllAutoClosingPairDelete.js

@@ -0,0 +1,14 @@
+import * as IsAutoClosingPairDelete from '../IsAutoClosingPairDelete/IsAutoClosingPairDelete.js'
+
+export const isAllAutoClosingPairDelete = (autoClosingRanges, selections) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const startRowIndex = selections[i]
+    const startColumnIndex = selections[i + 1]
+    const endRowIndex = selections[i + 2]
+    const endColumnIndex = selections[i + 3]
+    if (!IsAutoClosingPairDelete.isAutoClosingPairDelete(autoClosingRanges, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex)) {
+      return false
+    }
+  }
+  return true
+}

package/static/5a94137/packages/renderer-worker/src/parts/IsAutoClosingPairDelete/IsAutoClosingPairDelete.js

@@ -0,0 +1,20 @@
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+
+export const isAutoClosingPairDelete = (autoClosingRanges, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  if (!EditorSelection.isEmpty(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex)) {
+    return false
+  }
+  if (startColumnIndex < 1) {
+    return false
+  }
+  for (let j = 0; j < autoClosingRanges.length; j += 4) {
+    const autoStartRowIndex = autoClosingRanges[j]
+    const autoStartColumnIndex = autoClosingRanges[j + 1]
+    const autoEndRowIndex = autoClosingRanges[j + 2]
+    const autoEndColumnIndex = autoClosingRanges[j + 3]
+    if (startRowIndex === autoStartRowIndex && startColumnIndex === autoStartColumnIndex) {
+      return true
+    }
+  }
+  return false
+}

package/static/5a94137/packages/renderer-worker/src/parts/IsEmptyString/IsEmptyString.js

@@ -0,0 +1,3 @@
+export const isEmptyString = (string) => {
+  return string === ''
+}

package/static/5a94137/packages/renderer-worker/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1,31 @@
+import * as Callback from '../Callback/Callback.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as RestoreJsonRpcError from '../RestoreJsonRpcError/RestoreJsonRpcError.js'
+
+export const send = (transport, method, ...params) => {
+  transport.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params: params,
+  })
+}
+
+export const invoke = async (ipc, method, ...params) => {
+  const { id, promise } = Callback.registerPromise()
+  ipc.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
+  })
+  const responseMessage = await promise
+  if ('error' in responseMessage) {
+    const restoredError = RestoreJsonRpcError.restoreJsonRpcError(responseMessage.error)
+    throw restoredError
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+
+  throw new Error('unexpected response message')
+}

package/static/5a94137/packages/renderer-worker/src/parts/Location/Location.js

@@ -0,0 +1,21 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+export const getPathName = () => {
+  return RendererProcess.invoke(/* Location.getPathName */ 'Location.getPathName')
+}
+
+export const getHref = () => {
+  return RendererProcess.invoke(/* Location.getHref */ 'Location.getHref')
+}
+
+export const setPathName = (pathName) => {
+  return RendererProcess.invoke(/* Location.setPathName */ 'Location.setPathName', /* pathName */ pathName)
+}
+
+export const hydrate = () => {
+  return RendererProcess.invoke(/* Location.hydrate */ 'Location.hydrate')
+}
+
+export const getOrigin = () => {
+  return location.origin
+}

package/static/5a94137/packages/renderer-worker/src/parts/Logger/Logger.js

@@ -0,0 +1,11 @@
+export const info = (...args) => {
+  console.info(...args)
+}
+
+export const warn = (...args) => {
+  console.warn(...args)
+}
+
+export const error = (...args) => {
+  console.error(...args)
+}

package/static/5a94137/packages/renderer-worker/src/parts/MenuEntriesSearch/MenuEntriesSearch.js

@@ -0,0 +1,27 @@
+import * as I18nString from '../I18NString/I18NString.js'
+import * as MenuItemFlags from '../MenuItemFlags/MenuItemFlags.js'
+
+/**
+ * @enum {string}
+ */
+export const UiStrings = {
+  CopyPath: 'Copy Path',
+  Dismiss: 'Dismiss',
+}
+
+export const getMenuEntries = () => {
+  return [
+    {
+      id: 'dismiss',
+      label: I18nString.i18nString(UiStrings.Dismiss),
+      flags: MenuItemFlags.None,
+      command: /* TODO */ -1,
+    },
+    {
+      id: 'copyPath',
+      label: I18nString.i18nString(UiStrings.CopyPath),
+      flags: MenuItemFlags.None,
+      command: /* TODO */ -1,
+    },
+  ]
+}

package/static/5a94137/packages/renderer-worker/src/parts/MergeStacks/MergeStacks.js

@@ -0,0 +1,19 @@
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
+
+export const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = GetNewLineIndex.getNewLineIndex(parent)
+  const childNewLineIndex = GetNewLineIndex.getNewLineIndex(child)
+  if (childNewLineIndex === -1) {
+    return parent
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  const childFirstLine = child.slice(0, childNewLineIndex)
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest
+  }
+  return child
+}

package/static/5a94137/packages/renderer-worker/src/parts/MimeType/MimeType.js

@@ -0,0 +1,36 @@
+export const ApplicationFontWoff = 'application/font-woff'
+export const AudioMidi = 'audio/midi'
+export const AudioMpeg = 'audio/mpeg'
+export const AudioOgg = 'audio/ogg'
+export const AudioOpus = 'audio/opus'
+export const AudioXaac = 'audio/x-aac'
+export const AudioXMsWma = 'audio/x-ms-wma'
+export const AudioXWav = 'audio/x-wav'
+export const ImageAvif = 'image/avif'
+export const ImageBmp = 'image/bmp'
+export const ImageGif = 'image/gif'
+export const ImageJpg = 'image/jpg'
+export const ImagePng = 'image/png'
+export const ImageSvgXml = 'image/svg+xml'
+export const ImageTiff = 'image/tiff'
+export const ImageVndAdobePhotoShop = 'image/vnd.adobe.photoshop'
+export const ImageWebp = 'image/webp'
+export const ImageXIcon = 'image/x-icon'
+export const ImageXTga = 'image/x-tga'
+export const TextCalendar = 'text/calendar'
+export const TextCss = 'text/css'
+export const TextCvs = 'text/csv'
+export const TextHtml = 'text/html'
+export const TextJavaScript = 'text/javascript'
+export const TextPlain = 'text/plain'
+export const TextXml = 'text/xml'
+export const VideoMp4 = 'video/mp4'
+export const VideoMpeg = 'video/mpeg'
+export const VideoQuickTime = 'video/quicktime'
+export const VideoWebm = 'video/webm'
+export const VideoXFlv = 'video/x-flv'
+export const VideoXMatroska = 'video/x-matroska'
+export const VideoXMsVideo = 'video/x-msvideo'
+export const VideoXMsWmv = 'video/x-ms-wmv'
+export const VideoXSgiMovie = 'video/x-sgi-movie'
+export const ApplicationJson = 'aplication/json'