@lvce-editor/test-with-playwright-worker 1.7.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "1.7.0",
+  "version": "2.1.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -13,16 +13,15 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@lvce-editor/verror": "^1.5.0",
     "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/command": "^1.2.0",
+    "@lvce-editor/ipc": "^11.1.0",
+    "@lvce-editor/json-rpc": "^5.0.0",
+    "@lvce-editor/verror": "^1.6.0",
     "@playwright/test": "^1.48.2",
-    "get-port": "^7.1.0",
-    "minimist": "^1.2.8",
-    "read-pkg-up": "^11.0.0",
-    "verror": "^1.10.1"
+    "get-port": "^7.1.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.10",
-    "@types/verror": "^1.10.10"
+    "@types/jest": "^29.5.10"
   }
 }

package/src/parts/Command/Command.js

@@ -1,9 +1 @@
-import * as CommandState from '../CommandState/CommandState.js'
-
-export const execute = (command, ...args) => {
-  const fn = CommandState.getCommand(command)
-  if (!fn) {
-    throw new Error(`Command not found ${command}`)
-  }
-  return fn(...args)
-}
+export * from '@lvce-editor/command'

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -1,19 +1,2 @@
-export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
-export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
-export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
-export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
-export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
-export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
-export const EACCES = 'EACCES'
-export const ECONNRESET = 'ECONNRESET'
-export const EEXIST = 'EEXIST'
-export const EISDIR = 'EISDIR'
-export const ELOOP = 'ELOOP'
 export const ENOENT = 'ENOENT'
-export const ENOTDIR = 'ENOTDIR'
-export const EPERM = 'EPERM'
-export const EPIPE = 'EPIPE'
-export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
-export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
-export const EXDEV = 'EXDEV'
 export const E_NO_TEST_FILES = 'E_NO_TEST_FILES'

package/src/parts/GetServerPath/GetServerPath.js

@@ -1,9 +1,10 @@
-import { join } from 'path'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 export const getServerPath = async () => {
   const toTry = [
     '@lvce-editor/server',
-    join(process.cwd(), '..', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js'),
+    pathToFileURL(join(process.cwd(), '..', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(),
   ]
 
   for (const path of toTry) {

package/src/parts/GetTests/GetTests.js

@@ -4,13 +4,19 @@ import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as IsTestFile from '../IsTestFile/IsTestFile.js'
 import { NoTestFilesFoundError } from '../NoTestFilesFoundError/NoTestFilesFoundError.js'
 
+const getName = (dirent) => {
+  return dirent.name
+}
+
 /**
  * @param {string} testSrc
  */
 export const getTests = async (testSrc) => {
   try {
-    const dirents = await readdir(testSrc)
-    return dirents.filter(IsTestFile.isTestFile)
+    const dirents = await readdir(testSrc, {
+      withFileTypes: true,
+    })
+    return dirents.filter(IsTestFile.isTestFile).map(getName)
   } catch (error) {
     if (IsEnoentError.isEnoentError(error)) {
       throw new NoTestFilesFoundError(testSrc)

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,13 +1,5 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
+import * as HandleMessage from '../HandleMessage/HandleMessage.js'
 
 export const handleIpc = (ipc) => {
-  Assert.object(ipc)
-  const handleMessage = async (message) => {
-    const response = await GetResponse.getResponse(message, ipc)
-    if (response) {
-      ipc.send(response)
-    }
-  }
-  ipc.on('message', handleMessage)
+  ipc.addEventListener('message', HandleMessage.handleMessage)
 }

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,29 @@
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+const prepare = (error) => {
+  return error
+}
+
+const requiresSocket = (method) => {
+  if (method === 'RunAllTests') {
+    return true
+  }
+  return false
+}
+
+const logError = (error) => {
+  console.error(error)
+}
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(
+    event.target,
+    event.data,
+    Command.execute,
+    JsonRpc.resolve,
+    prepare,
+    logError,
+    requiresSocket,
+  )
+}

package/src/parts/IpcChild/IpcChild.js

@@ -4,6 +4,12 @@ export const listen = async ({ method, ...params }) => {
   const module = await IpcChildModule.getModule(method)
   // @ts-ignore
   const rawIpc = await module.listen(params)
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc)
+  }
+  // @ts-ignore
   const ipc = module.wrap(rawIpc)
   return ipc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,11 +1,24 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from '@lvce-editor/ipc'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 
 export const getModule = (method) => {
   switch (method) {
     case IpcChildType.NodeForkedProcess:
-      return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
+      return IpcChildWithNodeForkedProcess
     case IpcChildType.NodeWorker:
-      return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+      return IpcChildWithNodeWorker
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,5 +1,8 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
+export const ElectronMessagePort = 4
+export const WebSocket = 6
 
 export const Auto = () => {
   const { argv } = process
@@ -9,5 +12,8 @@ export const Auto = () => {
   if (argv.includes('--ipc-type=node-forked-process')) {
     return NodeForkedProcess
   }
-  throw new Error(`[test-worker] unknown ipc type`)
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
+  throw new Error(`[shared-process] unknown ipc type`)
 }

package/src/parts/IsTestFile/IsTestFile.js

@@ -1,6 +1,8 @@
+import { Dirent } from 'node:fs'
+
 /**
- * @param {string} name
+ * @param {Dirent} dirent
  */
-export const isTestFile = (name) => {
-  return !name.startsWith('_')
+export const isTestFile = (dirent) => {
+  return dirent.isFile() && !dirent.name.startsWith('_')
 }

package/src/parts/JsonRpc/JsonRpc.js

@@ -1,35 +1 @@
-import * as Callback from '../Callback/Callback.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const send = (transport, method, ...params) => {
-  transport.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params,
-  })
-}
-
-export const invoke = (ipc, method, ...params) => {
-  const { id, promise } = Callback.registerPromise()
-  ipc.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params,
-    id,
-  })
-  return promise
-}
-
-export const invokeAndTransfer = (ipc, handle, method, ...params) => {
-  const { id, promise } = Callback.registerPromise()
-  ipc.sendAndTransfer(
-    {
-      jsonrpc: JsonRpcVersion.Two,
-      method,
-      params,
-      id,
-    },
-    handle
-  )
-  return promise
-}
+export * from '@lvce-editor/json-rpc'

package/src/parts/Main/Main.js

@@ -1,5 +1,5 @@
+import * as Command from '@lvce-editor/command'
 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'
@@ -28,7 +28,7 @@ export const main = async () => {
   Process.on('SIGINT', handleSigint)
   Process.on('SIGTERM', handleSigTerm)
   Process.on('uncaughtExceptionMonitor', ProcessListeners.handleUncaughtExceptionMonitor)
-  CommandState.registerCommands(CommandMap.commandMap)
+  Command.register(CommandMap.commandMap)
   const ipc = await IpcChild.listen({
     method: IpcChildType.Auto(),
   })

package/src/parts/Process/Process.js

@@ -1,15 +1,3 @@
-export const argv = process.argv
-
-export const env = process.env
-
-/**
- *
- * @param {number} code
- */
-export const exit = (code) => {
-  process.exit(code)
-}
-
 /**
  *
  * @param {string} event

package/src/parts/Callback/Callback.js

@@ -1,39 +0,0 @@
-import * as Id from '../Id/Id.js'
-
-export const state = {
-  callbacks: Object.create(null),
-  onceListeners: new Set(),
-}
-
-export const registerPromise = () => {
-  const id = Id.create()
-  const promise = new Promise((resolve, reject) => {
-    state.callbacks[id] = { resolve, reject }
-  })
-  return { id, promise }
-}
-
-// TODO merge resolve and resolveEmpty
-export const resolve = (id, args) => {
-  const { callbacks } = state
-  if (!(id in callbacks)) {
-    console.warn(`callback ${id} may already be disposed`)
-    return
-  }
-  callbacks[id].resolve(args)
-  delete callbacks[id]
-}
-
-export const reject = (id, error) => {
-  const { callbacks } = state
-  if (!(id in callbacks)) {
-    console.warn(`callback (rejected) ${id} may already be disposed`)
-    return
-  }
-  callbacks[id].reject(error)
-  delete callbacks[id]
-}
-
-export const isAllEmpty = () => {
-  return Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
-}

package/src/parts/Character/Character.js

@@ -1,11 +0,0 @@
-export const Backslash = '\\'
-export const Dash = '-'
-export const Dot = '.'
-export const EmptyString = ''
-export const NewLine = '\n'
-export const OpenAngleBracket = '<'
-export const Slash = '/'
-export const Space = ' '
-export const Tab = '\t'
-export const Underline = '_'
-export const T = 't'

package/src/parts/CleanStack/CleanStack.js

@@ -1,93 +0,0 @@
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-const RE_AT = /^\s+at/
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
-const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/
-const RE_GET_RESPONSE = /^\s*at async getResponse/
-const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/
-const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/
-const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/
-
-const isInternalLine = (line) => {
-  return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
-}
-
-const isRelevantLine = (line) => {
-  return !isInternalLine(line)
-}
-
-const isApplicationUsefulLine = (line, index) => {
-  if (index === 0) {
-    return true
-  }
-  if (RE_GET_RESPONSE.test(line)) {
-    return false
-  }
-  if (RE_WEBSOCKET_HANDLE_MESSAGE.test(line)) {
-    return false
-  }
-  if (RE_EXECUTE_COMMAND_ASYNC.test(line)) {
-    return false
-  }
-  if (RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT.test(line)) {
-    return false
-  }
-  return true
-}
-
-const isNormalStackLine = (line) => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
-}
-
-const cleanLine = (line) => {
-  if (line.startsWith('    at exports.')) {
-    return '    at ' + line.slice('    at exports.'.length)
-  }
-  if (line.startsWith('    at async exports.')) {
-    return '    at async ' + line.slice('    at async exports.'.length)
-  }
-  if (line.startsWith('    at async Module.')) {
-    return '    at async ' + line.slice('    at async Module.'.length)
-  }
-  if (line.startsWith('    at Module.')) {
-    return '    at ' + line.slice('    at Module.'.length)
-  }
-  const objectMatch = line.match(RE_OBJECT_AS)
-  if (objectMatch) {
-    const rest = line.slice(objectMatch[0].length)
-    if (objectMatch[1]) {
-      return '    at ' + objectMatch[1] + objectMatch[2] + rest
-    }
-    return '    at ' + objectMatch[2] + rest
-  }
-  return line
-}
-
-const getDetails = (lines) => {
-  const index = lines.findIndex(isNormalStackLine)
-  return {
-    custom: lines.slice(0, index),
-    actualStack: lines.slice(index).map(cleanLine),
-  }
-}
-
-const RE_PATH_1 = /^\/(.*)(\d+)$/
-
-const mergeCustom = (custom, relevantStack) => {
-  if (custom.length === 0) {
-    return relevantStack
-  }
-  const firstLine = custom[0]
-  if (RE_PATH_1.test(firstLine)) {
-    return [`    at ${firstLine}`, ...relevantStack]
-  }
-  return relevantStack
-}
-
-export const cleanStack = (stack) => {
-  const lines = SplitLines.splitLines(stack)
-  const { custom, actualStack } = getDetails(lines)
-  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine)
-  const merged = mergeCustom(custom, relevantStack)
-  return merged
-}

package/src/parts/Cli/Cli.js

@@ -1,8 +0,0 @@
-import * as HandleCliArgs from '../HandleCliArgs/HandleCliArgs.js'
-import * as Process from '../Process/Process.js'
-
-export const main = () => {
-  HandleCliArgs.handleCliArgs({ argv: Process.argv, env: Process.env })
-}
-
-main()

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

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

package/src/parts/CommandState/CommandState.js

@@ -1,17 +0,0 @@
-export const state = {
-  commands: Object.create(null),
-}
-
-export const registerCommand = (key, fn) => {
-  state.commands[key] = fn
-}
-
-export const registerCommands = (commandMap) => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value)
-  }
-}
-
-export const getCommand = (key) => {
-  return state.commands[key]
-}

package/src/parts/EncodingType/EncodingType.js

@@ -1 +0,0 @@
-export const Utf8 = 'utf8'

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -1,56 +0,0 @@
-import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
-import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
-
-const shouldLogError = (error) => {
-  if (error && error.code === ErrorCodes.ENOENT) {
-    return false
-  }
-  return true
-}
-
-export const getErrorResponse = (message, error) => {
-  if (error && error instanceof CommandNotFoundError) {
-    return {
-      jsonrpc: JsonRpcVersion.Two,
-      id: message.id,
-      error: {
-        code: JsonRpcErrorCode.MethodNotFound,
-        message: error.message,
-        data: error.stack,
-      },
-    }
-  }
-  if (!shouldLogError(error)) {
-    return {
-      jsonrpc: JsonRpcVersion.Two,
-      id: message.id,
-      error: {
-        code: JsonRpcErrorCode.Custom,
-        message: `${error}`,
-        data: {
-          code: error.code,
-        },
-      },
-    }
-  }
-  const prettyError = PrettyError.prepare(error)
-  PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
-  return {
-    jsonrpc: JsonRpcVersion.Two,
-    id: message.id,
-    error: {
-      code: JsonRpcErrorCode.Custom,
-      message: prettyError.message,
-      data: {
-        stack: prettyError.stack,
-        codeFrame: prettyError.codeFrame,
-        type: prettyError.type,
-        code: prettyError.code,
-      },
-    },
-  }
-}

package/src/parts/GetResponse/GetResponse.js

@@ -1,12 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
-import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
-
-export const getResponse = async (message, ipc) => {
-  try {
-    const result = await Command.execute(message.method, ipc, ...message.params)
-    return GetSuccessResponse.getSuccessResponse(message, result)
-  } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error)
-  }
-}

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

@@ -1,12 +0,0 @@
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const getSuccessResponse = (message, result) => {
-  if (!message.id) {
-    return undefined
-  }
-  return {
-    jsonrpc: JsonRpcVersion.Two,
-    id: message.id,
-    result: result ?? null,
-  }
-}

package/src/parts/HandleCliArgs/HandleCliArgs.js

@@ -1,20 +0,0 @@
-import * as RunAllTests from '../RunAllTests/RunAllTests.js'
-
-/**
- *
- * @param {{argv:string[], env:any}} param0
- */
-export const handleCliArgs = async ({ argv, env }) => {
-  const cwd = process.cwd()
-  const extensionPath = env.ONLY_EXTENSION
-  const testPath = env.TEST_PATH || ''
-  const headless = argv.includes('--headless')
-  // TODO
-  // @ts-ignore
-  await RunAllTests.runAllTests({
-    extensionPath,
-    testPath,
-    cwd,
-    headless,
-  })
-}

package/src/parts/Id/Id.js

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

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -1,41 +0,0 @@
-import { IpcError } from '../IpcError/IpcError.js'
-
-export const listen = async () => {
-  if (!process.send) {
-    throw new IpcError('process ipc is not available')
-  }
-  process.send('ready')
-  return process
-}
-
-const getActualData = (message, handle) => {
-  if (handle) {
-    return {
-      ...message,
-      params: [...message.params, handle],
-    }
-  }
-  return message
-}
-
-export const wrap = (process) => {
-  return {
-    process,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (message, handle) => {
-          const actualData = getActualData(message, handle)
-          listener(actualData)
-        }
-        this.process.on(event, wrappedListener)
-      }
-    },
-    off(event, listener) {
-      this.process.off(event, listener)
-    },
-    send(message) {
-      this.process.send(message)
-    },
-    dispose() {},
-  }
-}

package/src/parts/IpcChildWithNodeWorker/IpcChildWithNodeWorker.js

@@ -1,27 +0,0 @@
-import { parentPort } from 'node:worker_threads'
-
-export const listen = async () => {
-  if (!parentPort) {
-    throw new Error('parentPort is required')
-  }
-  parentPort.postMessage('ready')
-  return parentPort
-}
-
-export const wrap = (parentPort) => {
-  return {
-    parentPort,
-    on(event, listener) {
-      this.parentPort.on(event, listener)
-    },
-    off(event, listener) {
-      this.parentPort.off(event, listener)
-    },
-    send(message) {
-      this.parentPort.postMessage(message)
-    },
-    dispose() {
-      this.parentPort.close()
-    },
-  }
-}

package/src/parts/IpcError/IpcError.js

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

package/src/parts/JoinLines/JoinLines.js

@@ -1,5 +0,0 @@
-import * as Character from '../Character/Character.js'
-
-export const joinLines = (lines) => {
-  return lines.join(Character.NewLine)
-}

package/src/parts/Json/Json.js

@@ -1,17 +0,0 @@
-// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
-
-import { JsonParsingError } from '../JsonParsingError/JsonParsingError.js'
-
-export const parse = async (string, filePath) => {
-  try {
-    return JSON.parse(string)
-  } catch (error) {
-    const JsonError = await import('../JsonError/JsonError.js')
-    const errorProps = JsonError.getErrorPropsFromError(error, string, filePath)
-    throw new JsonParsingError(errorProps.message, errorProps.codeFrame, errorProps.stack)
-  }
-}
-
-export const stringify = (value) => {
-  return JSON.stringify(value, null, 2) + '\n'
-}

package/src/parts/JsonError/JsonError.js

@@ -1,64 +0,0 @@
-import { codeFrameColumns } from '@babel/code-frame'
-import { LinesAndColumns } from 'lines-and-columns'
-
-// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
-
-const emptyError = {
-  message: '',
-  stack: '',
-  codeFrame: '',
-}
-
-export const getErrorPropsFromError = (error, string, filePath) => {
-  const indexMatch = error.message.match(/in JSON at position (\d+)/)
-  if (indexMatch && indexMatch.length > 0) {
-    const lines = new LinesAndColumns(string)
-    const index = Number(indexMatch[1])
-    const location = lines.locationForIndex(index)
-    if (location) {
-      const line = location.line + 1
-      const column = location.column + 1
-      const codeFrame = codeFrameColumns(string, { start: { line, column } }, { highlightCode: false })
-      return {
-        codeFrame,
-        message: 'Json Parsing Error',
-        stack: `    at ${filePath}:${line}:${column}`,
-      }
-    }
-  }
-  if (string.length === 0) {
-    return {
-      codeFrame: ``,
-      message: 'Json Parsing Error: Cannot parse empty string',
-      stack: `    at ${filePath}`,
-    }
-  }
-
-  if (error.message === 'Unexpected end of JSON input') {
-    const lines = new LinesAndColumns(string)
-    const index = string.length - 1
-    const location = lines.locationForIndex(index)
-    if (location) {
-      const codeFrame = codeFrameColumns(string, { start: { line: location.line + 1, column: location.column + 1 } }, { highlightCode: false })
-      return {
-        codeFrame,
-        message: 'Json Parsing Error',
-        stack: `    at ${filePath}`,
-      }
-    }
-  }
-  return {
-    codeFrame: ``,
-    message: 'Json Parsing Error',
-    stack: `    at ${filePath}`,
-  }
-}
-
-export const getErrorProps = (string, filePath) => {
-  try {
-    JSON.parse(string)
-    return emptyError
-  } catch (error) {
-    return getErrorPropsFromError(error, string, filePath)
-  }
-}

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -1,17 +0,0 @@
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-export class JsonParsingError extends Error {
-  constructor(message, codeFrame, stack) {
-    super(message)
-    this.name = 'JsonParsingError'
-    if (codeFrame) {
-      this.codeFrame = codeFrame
-    }
-
-    if (stack) {
-      const parentStack = JoinLines.joinLines(SplitLines.splitLines(this.stack).slice(1))
-      this.stack = this.name + ': ' + this.message + '\n' + stack + '\n' + parentStack
-    }
-  }
-}

package/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

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

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

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

package/src/parts/Logger/Logger.js

@@ -1,43 +0,0 @@
-// TODO mock this module when used in unit tests
-
-const state = {
-  /**
-   * @type {Console|undefined}
-   */
-  console: undefined,
-}
-
-const createConsole = () => {
-  return console
-}
-
-const getOrCreateLogger = () => {
-  if (!state.console) {
-    state.console = createConsole()
-  }
-  return state.console
-}
-
-export const log = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.log(...args)
-  console.log(...args)
-}
-
-export const info = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.info(...args)
-  console.info(...args)
-}
-
-export const warn = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.warn(...args)
-  console.warn(...args)
-}
-
-export const error = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.error(...args)
-  console.error(...args)
-}

package/src/parts/PrettyError/PrettyError.js

@@ -1,138 +0,0 @@
-import { codeFrameColumns } from '@babel/code-frame'
-import { LinesAndColumns } from 'lines-and-columns'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import * as CleanStack from '../CleanStack/CleanStack.js'
-import * as EncodingType from '../EncodingType/EncodingType.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as Json from '../Json/Json.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-const getActualPath = (fileUri) => {
-  if (fileUri.startsWith('file://')) {
-    return fileURLToPath(fileUri)
-  }
-  return fileUri
-}
-
-const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/
-
-const prepareModuleNotFoundError = (error) => {
-  const { message } = error
-  const match = message.match(RE_MODULE_NOT_FOUND_STACK)
-  if (!match) {
-    return {
-      message,
-      stack: error.stack,
-      codeFrame: '',
-    }
-  }
-  const notFoundModule = match[1]
-  const importedFrom = match[2]
-  const rawLines = readFileSync(importedFrom, EncodingType.Utf8)
-  let line = 0
-  let column = 0
-  const splittedLines = SplitLines.splitLines(rawLines)
-  for (let i = 0; i < splittedLines.length; i++) {
-    const splittedLine = splittedLines[i]
-    const index = splittedLine.indexOf(notFoundModule)
-    if (index !== -1) {
-      line = i + 1
-      column = index
-      break
-    }
-  }
-  const location = {
-    start: {
-      line,
-      column,
-    },
-  }
-  const codeFrame = codeFrameColumns(rawLines, location)
-  const stackLines = SplitLines.splitLines(error.stack)
-  const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)]
-  const newStack = JoinLines.joinLines(newStackLines)
-  return {
-    message,
-    stack: newStack,
-    codeFrame,
-  }
-}
-
-const getStackLinesToCut = (error) => {
-  if (error && error.name === 'AssertionError') {
-    return 1
-  }
-  return 0
-}
-
-export const prepare = (error) => {
-  if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
-    return prepareModuleNotFoundError(error)
-  }
-  const { message } = error
-  if (error && error.cause) {
-    const cause = error.cause()
-    if (cause) {
-      error = cause
-    }
-  }
-  const linesToCut = getStackLinesToCut(error)
-  const lines = CleanStack.cleanStack(error.stack).slice(linesToCut)
-  const file = lines[0]
-  let codeFrame = ''
-  if (error.codeFrame) {
-    codeFrame = error.codeFrame
-  } else if (file) {
-    let match = file.match(/\((.*):(\d+):(\d+)\)$/)
-    if (!match) {
-      match = file.match(/at (.*):(\d+):(\d+)$/)
-    }
-    if (match) {
-      const [_, path, line, column] = match
-      const actualPath = getActualPath(path)
-      const rawLines = readFileSync(actualPath, EncodingType.Utf8)
-      const location = {
-        start: {
-          line: Number.parseInt(line),
-          column: Number.parseInt(column),
-        },
-      }
-      codeFrame = codeFrameColumns(rawLines, location)
-    }
-  }
-  const relevantStack = JoinLines.joinLines(lines)
-  return {
-    message,
-    stack: relevantStack,
-    codeFrame,
-    type: error.constructor.name,
-    code: error.code,
-  }
-}
-
-const fixBackslashes = (string) => {
-  return string.replaceAll('\\\\', '\\')
-}
-
-export const prepareJsonError = (json, property, message) => {
-  const string = fixBackslashes(Json.stringify(json))
-  const stringifiedPropertyName = `"${property}"`
-  const index = string.indexOf(stringifiedPropertyName) // TODO this could be wrong in some cases, find a better way
-  console.log({ string, index })
-  const jsonError = {
-    stack: '',
-  }
-  if (index !== -1) {
-    const lines = new LinesAndColumns(string)
-    const location = lines.locationForIndex(index + stringifiedPropertyName.length + 1)
-    const codeFrame = codeFrameColumns(string, {
-      // @ts-ignore
-      start: { line: location.line + 1, column: location.column + 1 },
-    })
-    jsonError.codeFrame = codeFrame
-  }
-  // jsonError.stack = `${bottomMessage}\n    at ${filePath}`
-  return jsonError
-}

package/src/parts/PrintPrettyError/PrintPrettyError.js

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

package/src/parts/SplitLines/SplitLines.js

@@ -1,5 +0,0 @@
-import * as Character from '../Character/Character.js'
-
-export const splitLines = (lines) => {
-  return lines.split(Character.NewLine)
-}