@lvce-editor/static-server 0.40.0

package/static/c76328b/packages/extension-host-sub-worker/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,18 @@
+export const WebSocket = 1
+export const MessagePort = 2
+export const Parent = 3
+export const ElectronMessagePort = 4
+export const ElectronUtilityProcess = 5
+export const ElectronUtilityProcessMessagePort = 6
+export const ModuleWorker = 7
+export const ModuleWorkerAndMessagePort = 8
+
+export const Auto = () => {
+  if (globalThis.acceptPort) {
+    return MessagePort
+  }
+  if (globalThis.acceptReferencePort) {
+    return 0
+  }
+  return ModuleWorkerAndMessagePort
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/IpcChildWithMessagePort/IpcChildWithMessagePort.js

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

package/static/c76328b/packages/extension-host-sub-worker/src/parts/IpcChildWithModuleWorker/IpcChildWithModuleWorker.js

@@ -0,0 +1,40 @@
+import { IpcError } from '../IpcError/IpcError.js'
+import * as GetData from '../GetData/GetData.js'
+
+export const listen = async () => {
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new IpcError('module is not in web worker scope')
+  }
+  globalThis.postMessage('ready')
+  return globalThis
+}
+
+export const wrap = (port) => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    send(message) {
+      this.port.postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      this.port.postMessage(message, transferables)
+    },
+    get onmessage() {
+      return this.wrappedListener
+    },
+    set onmessage(listener) {
+      if (listener) {
+        this.wrappedListener = (event) => {
+          const actualData = GetData.getData(event)
+          listener(actualData)
+        }
+      } else {
+        this.wrappedListener = undefined
+      }
+      this.port.onmessage = this.wrappedListener
+    },
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/IpcChildWithModuleWorkerAndMessagePort/IpcChildWithModuleWorkerAndMessagePort.js

@@ -0,0 +1,54 @@
+import * as GetData from '../GetData/GetData.js'
+import * as IpcChildWithModuleWorker from '../IpcChildWithModuleWorker/IpcChildWithModuleWorker.js'
+import { IpcError } from '../IpcError/IpcError.js'
+import * as WaitForFirstMessage from '../WaitForFirstMessage/WaitForFirstMessage.js'
+
+export const listen = async () => {
+  const parentIpcRaw = await IpcChildWithModuleWorker.listen()
+  const parentIpc = IpcChildWithModuleWorker.wrap(parentIpcRaw)
+  const firstMessage = await WaitForFirstMessage.waitForFirstMessage(parentIpc)
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message')
+  }
+  const type = firstMessage.params[0]
+  if (type === 'message-port') {
+    parentIpcRaw.postMessage({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null,
+    })
+    const port = firstMessage.params[1]
+    return port
+  }
+  return globalThis
+}
+
+export const wrap = (port) => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    send(message) {
+      this.port.postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      this.port.postMessage(message, transferables)
+    },
+    get onmessage() {
+      return this.wrappedListener
+    },
+    set onmessage(listener) {
+      if (listener) {
+        this.wrappedListener = (event) => {
+          const actualData = GetData.getData(event)
+          listener(actualData)
+        }
+      } else {
+        this.wrappedListener = undefined
+      }
+      this.port.onmessage = this.wrappedListener
+    },
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/IpcError/IpcError.js

@@ -0,0 +1,6 @@
+export class IpcError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'IpcError'
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JoinLines/JoinLines.js

@@ -0,0 +1,3 @@
+export const joinLines = (lines) => {
+  return lines.join('\n')
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1,16 @@
+import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
+import * as JsonRpcRequest from '../JsonRpcRequest/JsonRpcRequest.js'
+import * as UnwrapJsonRpcResult from '../UnwrapJsonRpcResult/UnwrapJsonRpcResult.js'
+
+export const send = (transport, method, ...params) => {
+  const message = JsonRpcEvent.create(method, params)
+  transport.send(message)
+}
+
+export const invoke = async (ipc, method, ...params) => {
+  const { message, promise } = JsonRpcRequest.create(method, params)
+  ipc.send(message)
+  const responseMessage = await promise
+  const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
+  return result
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpcError/JsonRpcError.js

@@ -0,0 +1,6 @@
+export class JsonRpcError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'JsonRpcError'
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

@@ -0,0 +1,2 @@
+export const MethodNotFound = -32601
+export const Custom = -32001

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpcEvent/JsonRpcEvent.js

@@ -0,0 +1,9 @@
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const create = (method, params) => {
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params: params,
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpcRequest/JsonRpcRequest.js

@@ -0,0 +1,16 @@
+import * as Callback from '../Callback/Callback.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const create = (method, params) => {
+  const { id, promise } = Callback.registerPromise()
+  const message = {
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
+  }
+  return {
+    message,
+    promise,
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/JsonRpcVersion/JsonRpcVersion.js

@@ -0,0 +1 @@
+export const Two = '2.0'

package/static/c76328b/packages/extension-host-sub-worker/src/parts/Listen/Listen.js

@@ -0,0 +1,19 @@
+import * as Command from '../Command/Command.js'
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const listen = async () => {
+  CommandState.registerCommands(CommandMap.commandMap)
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
+  HandleIpc.handleIpc(ipc, Command.execute)
+  const rpc = {
+    invoke(method, ...params) {
+      return JsonRpc.invoke(ipc, method, ...params)
+    },
+  }
+  globalThis.rpc = rpc
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/LoadFile/LoadFile.js

@@ -0,0 +1,14 @@
+import * as Assert from '../Assert/Assert.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as ImportScript from '../ImportScript/ImportScript.js'
+
+export const loadFile = async (path) => {
+  Assert.string(path)
+  const module = await ImportScript.importScript(path)
+  if (module && module.commandMap) {
+    const commandMap = module.commandMap
+    CommandState.registerCommands(commandMap)
+  } else {
+    throw new Error(`missing commandMap export`)
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/LoadKy/LoadKy.js

@@ -0,0 +1,11 @@
+import * as AssetDir from '../AssetDir/AssetDir.js'
+
+/**
+ *
+ * @returns {Promise<any>}
+ */
+export const loadKy = async () => {
+  const url = `${AssetDir.assetDir}/js/ky.js`
+  const module = await import(url)
+  return module
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/Main/Main.js

@@ -0,0 +1,5 @@
+import * as Listen from '../Listen/Listen.js'
+
+export const main = async () => {
+  await Listen.listen()
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/MergeStacks/MergeStacks.js

@@ -0,0 +1,20 @@
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.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 = NormalizeErrorLine.normalizeLine(child.slice(0, childNewLineIndex))
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest
+  }
+  return child
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/NormalizeErrorLine/NormalizeErrorLine.js

@@ -0,0 +1,9 @@
+export const normalizeLine = (line) => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length)
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length)
+  }
+  return line
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/Platform/Platform.js

@@ -0,0 +1,19 @@
+import * as PlatformType from '../PlatformType/PlatformType.js'
+
+const getPlatform = () => {
+  // @ts-ignore
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-ignore
+    return PLATFORM
+  }
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return 'test'
+  }
+  // TODO find a better way to pass runtime environment
+  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
+    return PlatformType.Electron
+  }
+  return PlatformType.Remote
+}
+
+export const platform = getPlatform() // TODO tree-shake this out in production

package/static/c76328b/packages/extension-host-sub-worker/src/parts/PlatformType/PlatformType.js

@@ -0,0 +1,5 @@
+export const Web = 'web'
+
+export const Electron = 'electron'
+
+export const Remote = 'remote'

package/static/c76328b/packages/extension-host-sub-worker/src/parts/PrettyError/PrettyError.js

@@ -0,0 +1,139 @@
+import * as Ajax from '../Ajax/Ajax.js'
+import * as CodeFrameColumns from '../CodeFrameColumns/CodeFrameColumns.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const getErrorMessage = (error) => {
+  if (!error) {
+    return `Error: ${error}`
+  }
+  let message = error.message
+  while (error.cause) {
+    error = error.cause
+    message += `: ${error}`
+  }
+  return message
+}
+
+const prepareErrorMessageWithCodeFrame = (error) => {
+  if (!error) {
+    return {
+      message: error,
+      stack: undefined,
+      codeFrame: undefined,
+      type: 'Error',
+    }
+  }
+  const message = getErrorMessage(error)
+  if (error.codeFrame) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: error.codeFrame,
+      type: error.constructor.name,
+    }
+  }
+  return {
+    message,
+    stack: error.originalStack,
+    codeFrame: error.originalCodeFrame,
+    category: error.category,
+    stderr: error.stderr,
+  }
+}
+
+const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/
+const RE_PATH_2 = /at (.*):(\d+):(\d+)$/
+
+/**
+ *
+ * @param {readonly string[]} lines
+ * @returns
+ */
+const getFile = (lines) => {
+  for (const line of lines) {
+    if (RE_PATH_1.test(line) || RE_PATH_2.test(line)) {
+      return line
+    }
+  }
+  return ''
+}
+
+const prepareErrorMessageWithoutCodeFrame = async (error) => {
+  try {
+    const lines = SplitLines.splitLines(error.stack)
+    const file = getFile(lines)
+    let match = file.match(RE_PATH_1)
+    if (!match) {
+      match = file.match(RE_PATH_2)
+    }
+    if (!match) {
+      return error
+    }
+    const [_, path, line, column] = match
+    const text = await Ajax.getText(path)
+    const parsedLine = Number.parseInt(line)
+    const parsedColumn = Number.parseInt(column)
+    const codeFrame = CodeFrameColumns.create(text, {
+      start: {
+        line: parsedLine,
+        column: parsedColumn,
+      },
+      end: {
+        line: parsedLine,
+        column: parsedColumn,
+      },
+    })
+    const relevantStack = JoinLines.joinLines(lines.slice(1))
+    const message = getErrorMessage(error)
+    return {
+      message,
+      codeFrame,
+      stack: relevantStack,
+      type: error.constructor.name,
+    }
+  } catch (otherError) {
+    console.warn('ErrorHandling Error')
+    console.warn(otherError)
+    return error
+  }
+}
+
+export const prepare = async (error) => {
+  if (error && error.message && error.codeFrame) {
+    return prepareErrorMessageWithCodeFrame(error)
+  }
+  if (error && error.stack) {
+    return prepareErrorMessageWithoutCodeFrame(error)
+  }
+  return error
+}
+
+export const print = (error) => {
+  if (error && error.type && error.message && error.codeFrame) {
+    return `${error.type}: ${error.message}\n\n${error.codeFrame}\n\n${error.stack}`
+  }
+  if (error && error.message && error.codeFrame) {
+    return `${error.message}\n\n${error.codeFrame}\n\n${error.stack}`
+  }
+  if (error && error.type && error.message) {
+    return `${error.type}: ${error.message}\n${error.stack}`
+  }
+  if (error && error.stack) {
+    return `${error.stack}`
+  }
+  if (error === null) {
+    return null
+  }
+  return `${error}`
+}
+
+export const getMessage = (error) => {
+  if (error && error.type && error.message) {
+    return `${error.type}: ${error.message}`
+  }
+  if (error && error.message) {
+    return `${error.constructor.name}: ${error.message}`
+  }
+  return `Error: ${error}`
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -0,0 +1,3 @@
+export const printPrettyError = (prettyError, prefix = '') => {
+  // Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/ProcessName/ProcessName.js

@@ -0,0 +1 @@
+export const processName = 'extension-host-sub-worker'

package/static/c76328b/packages/extension-host-sub-worker/src/parts/RestoreJsonRpcError/RestoreJsonRpcError.js

@@ -0,0 +1,78 @@
+import * as Character from '../Character/Character.js'
+import * as GetErrorConstructor from '../GetErrorConstructor/GetErrorConstructor.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const constructError = (message, type, name) => {
+  const ErrorConstructor = GetErrorConstructor.getErrorConstructor(message, type)
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name)
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message)
+    if (name && name !== 'VError') {
+      error.name = name
+    }
+    return error
+  }
+  return new ErrorConstructor(message)
+}
+
+const recreateStack = (message, stack) => {
+  if (message && !stack.includes(message)) {
+    return message + Character.NewLine + stack
+  }
+  return stack
+}
+
+const getErrorType = (error) => {
+  if (error && error.type) {
+    return error.type
+  }
+  if (error && error.data && error.data.type) {
+    return error.data.type
+  }
+  return ''
+}
+
+export const restoreJsonRpcError = (error) => {
+  if (error && error instanceof Error) {
+    return error
+  }
+  if (error && error.code && error.code === JsonRpcErrorCode.MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message)
+    restoredError.stack = error.stack || error.data || ''
+    return restoredError
+  }
+  if (error && error.message) {
+    const type = getErrorType(error)
+    const restoredError = constructError(error.message, type, error.name)
+    const currentStack = JoinLines.joinLines(SplitLines.splitLines(new Error().stack).slice(1))
+    if (error.data) {
+      if (error.data.stack && type && error.message) {
+        restoredError.stack = type + ': ' + error.message + Character.NewLine + error.data.stack + Character.NewLine + currentStack
+      } else if (error.data.stack) {
+        restoredError.stack = recreateStack(error.message, error.data.stack) + Character.NewLine + currentStack
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code
+      }
+    } else if (error.stack) {
+      // @ts-ignore
+      restoredError.stack = recreateStack(error.message, error.stack) + Character.NewLine + currentStack
+    }
+    return restoredError
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`)
+  }
+  console.log({ error })
+  return new Error(`JsonRpc Error: Unknown Error`)
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/SplitLines/SplitLines.js

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {string|undefined} lines
+ * @returns string[]
+ */
+export const splitLines = (lines) => {
+  if (!lines) {
+    return []
+  }
+  return lines.split('\n')
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/UnwrapJsonRpcResult/UnwrapJsonRpcResult.js

@@ -0,0 +1,13 @@
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+import * as RestoreJsonRpcError from '../RestoreJsonRpcError/RestoreJsonRpcError.js'
+
+export const unwrapJsonRpcResult = (responseMessage) => {
+  if ('error' in responseMessage) {
+    const restoredError = RestoreJsonRpcError.restoreJsonRpcError(responseMessage.error)
+    throw restoredError
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+  throw new JsonRpcError('unexpected response message')
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/VError/VError.js

@@ -0,0 +1,27 @@
+import * as MergeStacks from '../MergeStacks/MergeStacks.js'
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
+
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = NormalizeErrorLine.normalizeLine(`${error}`)
+  if (message) {
+    return `${message}: ${stringifiedError}`
+  }
+  return stringifiedError
+}
+
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+    if (error instanceof Error) {
+      this.stack = MergeStacks.mergeStacks(this.stack, error.stack)
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame
+    }
+    if (error.code) {
+      this.code = error.code
+    }
+  }
+}

package/static/c76328b/packages/extension-host-sub-worker/src/parts/WaitForFirstMessage/WaitForFirstMessage.js

@@ -0,0 +1,13 @@
+export const waitForFirstMessage = async (port) => {
+  const message = await new Promise((resolve) => {
+    const cleanup = (value) => {
+      port.onmessage = null
+      resolve(value)
+    }
+    const handleMessage = (message) => {
+      cleanup(message)
+    }
+    port.onmessage = handleMessage
+  })
+  return message
+}