@lvce-editor/server 0.0.26 → 0.0.29

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

@@ -0,0 +1,171 @@
+import * as Command from '../Command/Command.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as Languages from '../Languages/Languages.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Preferences from '../Preferences/Preferences.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+const CACHE_KEY = '/icon-theme.css'
+
+export const state = {
+  seenFiles: [],
+  seenFolders: [],
+  hasWarned: [],
+  iconTheme: undefined,
+}
+
+const DEFAULT_FILE_ICON = '_file'
+const DEFAULT_FOLDER_ICON = '_folder'
+const DEFAULT_FOLDER_ICON_OPEN = '_folder_open'
+
+const getIconThemeJson = async (iconThemeId) => {
+  if (Platform.getPlatform() === 'web') {
+    const assetDir = Platform.getAssetDir()
+    const url = `${assetDir}/icon-themes/${iconThemeId}.json`
+    const json = await Command.execute(
+      /* Ajax.getJson */ 'Ajax.getJson',
+      /* url */ url
+    )
+    return {
+      json,
+    }
+  }
+  return SharedProcess.invoke(
+    /* ExtensionHost.getIconThemeJson */ 'ExtensionHost.getIconThemeJson',
+    /* iconThemeId */ iconThemeId
+  )
+}
+
+const getExtension = (file) => {
+  return file.slice(file.lastIndexOf('.') + 1)
+}
+
+export const getFileIcon = (file) => {
+  const iconTheme = state.iconTheme
+  if (!iconTheme) {
+    return ''
+  }
+  const fileNameIcon = iconTheme.fileNames[file.name.toLowerCase()]
+  if (fileNameIcon) {
+    return fileNameIcon
+  }
+  const languageId = Languages.getLanguageId(file.name)
+  const languageIcon = iconTheme.languageIds[languageId]
+  if (languageIcon) {
+    return languageIcon
+  }
+  const extension = getExtension(file.name)
+  const extensionIcon = iconTheme.fileExtensions[extension]
+  if (extensionIcon) {
+    return extensionIcon
+  }
+  return DEFAULT_FILE_ICON
+}
+
+export const getFolderIcon = (folder) => {
+  const iconTheme = state.iconTheme
+  if (!iconTheme || !iconTheme.folderNames) {
+    return ''
+  }
+  const folderIcon = iconTheme.folderNames[folder.name.toLowerCase()]
+  if (folderIcon) {
+    return folderIcon
+  }
+  return DEFAULT_FOLDER_ICON
+}
+
+const getFolderIconExpanded = (folder) => {
+  const iconTheme = state.iconTheme
+  if (!iconTheme) {
+    return ''
+  }
+  if (!iconTheme.folderNamesExpanded) {
+    return DEFAULT_FOLDER_ICON_OPEN
+  }
+  const folderName = iconTheme.folderNamesExpanded[folder.name.toLowerCase()]
+  if (folderName) {
+    return folderName
+  }
+  return DEFAULT_FOLDER_ICON_OPEN
+}
+
+export const getIcon = (dirent) => {
+  switch (dirent.type) {
+    case 'file':
+      return getFileIcon(dirent)
+    case 'directory':
+    case 'folder':
+      return getFolderIcon(dirent)
+    case 'folder-expanded':
+    case 'directory-expanded':
+      return getFolderIconExpanded(dirent)
+    case 'symlink':
+      return DEFAULT_FILE_ICON
+    default:
+      console.warn(`unsupported type ${dirent.type}`)
+      return ''
+  }
+}
+
+const getBackgroundUrl = (extensionPath, value) => {
+  if (Platform.getPlatform() === 'web') {
+    return `/file-icons/${value.slice(7)}`
+  }
+  // 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 = []
+  for (const [key, value] of Object.entries(iconTheme.json.iconDefinitions)) {
+    const backgroundUrl = getBackgroundUrl(iconTheme.extensionPath, value)
+    rules.push(
+      `.Icon${key}::before { background-image: url(${backgroundUrl}) }`
+    )
+  }
+  const rulesCss = rules.join('\n')
+  return rulesCss
+}
+
+export const hydrate = async () => {
+  try {
+    // 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'
+    const iconTheme = await getIconThemeJson(iconThemeId)
+    state.iconTheme = iconTheme.json
+    state.extensionPath = iconTheme.extensionPath
+
+    const iconThemeCss = getIconThemeCss2(iconTheme)
+    await RendererProcess.invoke(
+      /* Css.setInlineStyle */ 'Css.setInlineStyle',
+      /* id */ 'ContributedIconTheme',
+      /* css */ iconThemeCss
+    )
+
+    await GlobalEventBus.emitEvent('iconTheme.change')
+    // GlobalEventBus.addListener('dirents.update', handleDirentsUpdate)
+    // GlobalEventBus.addListener('languages.changed', handleLanguagesUpdate)
+  } catch (error) {
+    // TODO
+    console.info(`[info] ${error.message}`)
+    // console.error(error)
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ImagePreview/ImagePreview.ipc.js

@@ -0,0 +1,8 @@
+import * as ImagePreview from './ImagePreview.js'
+
+// TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
+
+export const Commands = {
+  'ImagePreview.show': ImagePreview.show,
+  'ImagePreview.hide': ImagePreview.hide,
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IndexedDb/IndexedDb.js

@@ -0,0 +1,74 @@
+// TODO high memory usage in idb because of transactionDoneMap
+
+import { openDB } from '../../../../../static/js/idb/with-async-ittr.js'
+
+export const state = {
+  databases: Object.create(null),
+  eventId: 0,
+  dbVersion: 1,
+  /**
+   * @type {any}
+   */
+  cachedDb: undefined,
+}
+
+const getDb = async () => {
+  // @ts-ignore
+  const db = await openDB('session', state.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains('session')) {
+        const objectStore = await db.createObjectStore('session', {
+          autoIncrement: true,
+        })
+        objectStore.createIndex('sessionId', 'sessionId', { unique: false })
+      }
+    },
+  })
+  return db
+}
+
+const getDbMemoized = async () => {
+  if (!state.cachedDb) {
+    state.cachedDb = await getDb()
+  }
+  return state.cachedDb
+}
+
+export const saveValue = async (storeId, value) => {
+  try {
+    const db = await getDbMemoized()
+    await db.add('session', value)
+  } catch (error) {
+    throw new Error('Failed to save value to indexed db', {
+      // @ts-ignore
+      cause: error,
+    })
+  }
+}
+
+export const getValues = async (storeId) => {
+  try {
+    const db = await getDbMemoized()
+    const tx = db.transaction(storeId, 'readwrite')
+    const [objects] = await Promise.all([tx.store.getAll(), tx.done])
+    console.log({ objects })
+    return objects
+  } catch (error) {
+    throw new Error('Failed to get values from indexed db', {
+      // @ts-ignore
+      cause: error,
+    })
+  }
+}
+
+export const getValuesByIndexName = async (storeId, indexName, only) => {
+  const db = await getDbMemoized()
+  const transaction = db.transaction(storeId)
+  const index = transaction.store.index(indexName)
+  const iterator = index.iterate(only)
+  const objects = []
+  for await (const cursor of iterator) {
+    objects.push(cursor.value)
+  }
+  return objects
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/InitData/InitData.js

@@ -0,0 +1,18 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+export const getInitData = async () => {
+  const rendererProcessInitData = await RendererProcess.invoke(
+    'InitData.getInitData'
+  )
+  // TODO get the following items
+  // - location.href
+  // - workspace
+  // - color theme
+  // - preferences
+  // - restoredState
+  // - layout bounds
+  // - keybindings
+  // - icon theme
+  // - languages
+  return rendererProcessInitData
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,32 @@
+export const Methods = {
+  MessagePort: 1,
+  ModuleWorker: 2,
+  ReferencePort: 3,
+  get Auto() {
+    if (globalThis.acceptPort) {
+      return Methods.MessagePort
+    }
+    if (globalThis.acceptReferencePort) {
+      return Methods.ReferencePort
+    }
+    return Methods.ModuleWorker
+  },
+}
+
+const getModule = (method) => {
+  switch (method) {
+    case Methods.MessagePort:
+      return import('./IpcChildWithMessagePort.js')
+    case Methods.ModuleWorker:
+      return import('./IpcChildWithModuleWorker.js')
+    case Methods.ReferencePort:
+      return import('./IpcChildWithReferencePort.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}
+
+export const listen = async ({ method }) => {
+  const module = await getModule(method)
+  return module.listen()
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcChild/IpcChildWithMessagePort.js

@@ -0,0 +1,18 @@
+export const listen = () => {
+  const messageChannel = new MessageChannel()
+  globalThis.acceptPort(messageChannel.port2)
+  return {
+    send(message) {
+      messageChannel.port1.postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      messageChannel.port1.postMessage(message, transferables)
+    },
+    get onmessage() {
+      return messageChannel.port1.onmessage
+    },
+    set onmessage(listener) {
+      messageChannel.port1.onmessage = listener
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcChild/IpcChildWithModuleWorker.js

@@ -0,0 +1,17 @@
+export const listen = () => {
+  postMessage('ready')
+  return {
+    send(message) {
+      postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      postMessage(message, transferables)
+    },
+    get onmessage() {
+      return onmessage
+    },
+    set onmessage(listener) {
+      onmessage = listener
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcChild/IpcChildWithReferencePort.js

@@ -0,0 +1,23 @@
+export const listen = () => {
+  const referencePort = {
+    onmessage(message, transferables) {},
+    postMessage() {},
+  }
+  // TODO get rid of extra data wrapper
+  globalThis.acceptReferencePort(referencePort)
+  return {
+    send(message) {
+      referencePort.onmessage({ data: message })
+    },
+    sendAndTransfer({ data: message }, transferables) {
+      referencePort.onmessage(message, transferables)
+    },
+    get onmessage() {
+      // TODO
+      return null
+    },
+    set onmessage(listener) {
+      // TODO
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcParent/IpcParent.js

@@ -0,0 +1,29 @@
+export const Methods = {
+  Electron: 1,
+  MessagePort: 2,
+  ModuleWorker: 3,
+  ReferencePort: 4,
+  WebSocket: 5,
+}
+
+const getModule = (method) => {
+  switch (method) {
+    case Methods.Electron:
+      return import('./IpcParentWithElectron.js')
+    case Methods.MessagePort:
+      return import('./IpcParentWithMessagePort.js')
+    case Methods.ModuleWorker:
+      return import('./IpcParentWithModuleWorker.js')
+    case Methods.ReferencePort:
+      return import('./IpcParentWithReferencePort.js')
+    case Methods.WebSocket:
+      return import('./IpcParentWithWebSocket.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}
+
+export const create = async ({ method, ...options }) => {
+  const module = await getModule(method)
+  return module.create(options)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcParent/IpcParentWithElectron.js

@@ -0,0 +1,37 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+export const create = async (url, name) => {
+  const originalOnMessage = RendererProcess.state.ipc.onmessage
+  const port = await new Promise((resolve, reject) => {
+    RendererProcess.state.ipc.onmessage = (event) => {
+      const port = event.ports[0]
+      resolve(port)
+    }
+    RendererProcess.state.ipc.send('get-port')
+  })
+  RendererProcess.state.ipc.onmessage = originalOnMessage
+  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)
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcParent/IpcParentWithMessagePort.js

@@ -0,0 +1,35 @@
+import * as Assert from '../Assert/Assert.js'
+
+export const create = async ({ url }) => {
+  Assert.string(url)
+  const port = await new Promise((resolve) => {
+    globalThis.acceptPort = resolve
+    import(url)
+  })
+  delete globalThis.acceptPort
+  let handleMessage
+  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)
+          } else {
+            listener(event)
+          }
+        }
+      } else {
+        handleMessage = null
+      }
+      port.onmessage = handleMessage
+    },
+    send(message) {
+      port.postMessage(message)
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcParent/IpcParentWithModuleWorker.js

@@ -0,0 +1,119 @@
+const getDisplayName = (name) => {
+  if (!name) {
+    return '<unknown> worker'
+  }
+  if (name.endsWith('Worker')) {
+    return name.toLowerCase()
+  }
+  return `${name} worker`
+}
+
+const tryToGetActualErrorMessage = async ({ url, name }) => {
+  const displayName = getDisplayName(name)
+  try {
+    await import(url)
+    return `Failed to start ${displayName}: Unknown Error`
+  } catch (error) {
+    if (
+      error &&
+      error instanceof Error &&
+      error.message.startsWith('Failed to fetch dynamically imported module')
+    ) {
+      try {
+        const response = await fetch(url)
+        switch (response.status) {
+          case 404:
+            return `Failed to start ${displayName}: Not found (404)`
+          default:
+            return `Failed to start ${displayName}: Unknown Network Error`
+        }
+      } catch {
+        return `Failed to start ${displayName}: Unknown Network Error`
+      }
+    }
+    return `Failed to start ${displayName}: ${error}`
+  }
+}
+
+const isFirefoxError = (message) => {
+  return [
+    'SyntaxError: import declarations may only appear at top level of a module',
+    'SyntaxError: export declarations may only appear at top level of a module',
+  ].includes(message)
+}
+
+export const create = async ({ url, name }) => {
+  try {
+    const worker = new Worker(url, {
+      type: 'module',
+      name,
+    })
+    await new Promise((resolve, reject) => {
+      const cleanup = () => {
+        worker.onmessage = null
+        worker.onerror = null
+      }
+      const handleFirstMessage = (event) => {
+        cleanup()
+        if (event.data === 'ready') {
+          resolve(undefined)
+        } else {
+          reject(new Error('unexpected first message from renderer worker'))
+        }
+      }
+      const handleFirstError = async (event) => {
+        cleanup()
+        if (isFirefoxError(event.message)) {
+          event.preventDefault()
+          reject(new Error('module workers are not supported in firefox'))
+        } else {
+          const actualErrorMessage = await tryToGetActualErrorMessage({
+            url,
+            name,
+          })
+          reject(new Error(actualErrorMessage))
+        }
+      }
+      worker.onmessage = handleFirstMessage
+      worker.onerror = handleFirstError
+    })
+    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) {
+              const message = event.data
+              listener(message)
+            } else {
+              listener(event)
+            }
+          }
+        } else {
+          handleMessage = null
+        }
+        worker.onmessage = handleMessage
+      },
+      send(message) {
+        worker.postMessage(message)
+      },
+    }
+  } catch (error) {
+    if (
+      error &&
+      error instanceof Error &&
+      error.message === 'module workers are not supported in firefox'
+    ) {
+      const IpcParentWithMessagePort = await import(
+        './IpcParentWithMessagePort.js'
+      )
+      return IpcParentWithMessagePort.create({ url })
+    }
+    throw error
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/IpcParent/IpcParentWithReferencePort.js

@@ -0,0 +1,32 @@
+export const create = async ({ url }) => {
+  const referencePort = await new Promise((resolve) => {
+    globalThis.acceptReferencePort = resolve
+    import(url)
+  })
+  delete globalThis.acceptReferencePort
+  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) {
+            const message = event.data
+            listener(message)
+          } else {
+            listener(event)
+          }
+        }
+      } else {
+        handleMessage = null
+      }
+      referencePort.onmessage = handleMessage
+    },
+    send(message) {
+      referencePort.postMessage(message)
+    },
+  }
+}

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

@@ -0,0 +1,48 @@
+const getWsUrl = () => {
+  const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:'
+
+  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
+}