@lvce-editor/test-with-playwright-worker 4.1.0 → 5.0.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "4.1.0",
+  "version": "5.0.1",
   "description": "",
-  "main": "index.js",
+  "main": "src/workerMain.js",
   "type": "module",
   "repository": {
     "type": "git",
@@ -10,15 +10,14 @@
     "directory": "packages/test-with-playwright-worker"
   },
   "keywords": [],
-  "author": "",
+  "author": "Lvce Editor",
   "license": "MIT",
   "dependencies": {
     "@lvce-editor/assert": "^1.4.0",
-    "@lvce-editor/command": "^2.0.0",
-    "@lvce-editor/ipc": "^14.5.0",
-    "@lvce-editor/json-rpc": "^7.0.0",
+    "@lvce-editor/rpc": "^4.18.0",
+    "@lvce-editor/rpc-registry": "^3.6.0",
     "@lvce-editor/verror": "^1.7.0",
-    "@playwright/test": "^1.55.0",
+    "@playwright/test": "1.55.0",
     "get-port": "^7.1.0"
   },
   "devDependencies": {

package/src/parts/Main/Main.js

@@ -1,10 +1,9 @@
-import * as Command from '@lvce-editor/command'
+import { NodeWorkerRpcClient } from '@lvce-editor/rpc'
 import * as CommandMap from '../CommandMap/CommandMap.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 import * as Process from '../Process/Process.js'
 import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
+import { set } from '@lvce-editor/rpc-registry'
+import { Cli } from '../RpcId/RpcId.js'
 
 const handleDisconnect = () => {
   console.log('[test-worker] disconnected')
@@ -28,9 +27,8 @@ export const main = async () => {
   Process.on('SIGINT', handleSigint)
   Process.on('SIGTERM', handleSigTerm)
   Process.on('uncaughtExceptionMonitor', ProcessListeners.handleUncaughtExceptionMonitor)
-  Command.register(CommandMap.commandMap)
-  const ipc = await IpcChild.listen({
-    method: IpcChildType.Auto(),
+  const rpc = await NodeWorkerRpcClient.create({
+    commandMap: CommandMap.commandMap,
   })
-  HandleIpc.handleIpc(ipc)
+  set(Cli, rpc)
 }

package/src/parts/RpcId/RpcId.js

@@ -0,0 +1 @@
+export const Cli = 6001

package/src/parts/RunAllTests/RunAllTests.js

@@ -1,26 +1,27 @@
+import { get } from '@lvce-editor/rpc-registry'
 import { join } from 'path'
 import * as Assert from '../Assert/Assert.js'
+import * as CliCommandType from '../CliCommandType/CliCommandType.js'
 import * as GetTests from '../GetTests/GetTests.js'
+import { Cli } from '../RpcId/RpcId.js'
 import * as RunTests from '../RunTests/RunTests.js'
 import * as SetupTests from '../SetupTests/SetupTests.js'
 import * as TearDownTests from '../TearDownTests/TearDownTests.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as CliCommandType from '../CliCommandType/CliCommandType.js'
 
 /**
- * @param {any} ipc
  * @param {string} extensionPath
  * @param {string} testPath
  * @param {string} cwd
  * @param {boolean} headless
  * @param {number} headless
  */
-export const runAllTests = async (ipc, extensionPath, testPath, cwd, headless, timeout) => {
+export const runAllTests = async (extensionPath, testPath, cwd, headless, timeout) => {
   Assert.string(extensionPath)
   Assert.string(testPath)
   Assert.string(cwd)
   Assert.boolean(headless)
   Assert.number(timeout)
+  const rpc = get(Cli)
   const controller = new AbortController()
   const signal = controller.signal
   const { page, child, port } = await SetupTests.setupTests({
@@ -31,11 +32,11 @@ export const runAllTests = async (ipc, extensionPath, testPath, cwd, headless, t
   })
   const testSrc = join(testPath, 'src')
   const tests = await GetTests.getTests(testSrc)
-  const onResult = (result) => {
-    JsonRpc.send(ipc, CliCommandType.HandleResult, result)
+  const onResult = async (result) => {
+    await rpc.invoke(CliCommandType.HandleResult, result)
   }
   const onFinalResult = (finalResult) => {
-    JsonRpc.send(ipc, CliCommandType.HandleFinalResult, finalResult)
+    rpc.invoke(CliCommandType.HandleFinalResult, finalResult)
   }
   await RunTests.runTests({ testSrc, tests, headless, port, page, timeout, onResult, onFinalResult })
   await TearDownTests.tearDownTests({

package/src/parts/RunTests/RunTests.js

@@ -18,7 +18,7 @@ export const runTests = async ({ testSrc, tests, headless, page, port, timeout,
       port,
       timeout,
     })
-    onResult(result)
+    await onResult(result)
     switch (result.status) {
       case TestState.Fail:
         failed++
@@ -34,7 +34,7 @@ export const runTests = async ({ testSrc, tests, headless, page, port, timeout,
     }
   }
   const end = performance.now()
-  onFinalResult({
+  await onFinalResult({
     passed,
     failed,
     skipped,

package/index.js

@@ -1,6 +0,0 @@
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export const testWorkerPath = join(__dirname, 'src', 'workerMain.js')

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,5 +0,0 @@
-import * as HandleMessage from '../HandleMessage/HandleMessage.js'
-
-export const handleIpc = (ipc) => {
-  ipc.addEventListener('message', HandleMessage.handleMessage)
-}

package/src/parts/HandleMessage/HandleMessage.js

@@ -1,29 +0,0 @@
-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

@@ -1,15 +0,0 @@
-import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
-
-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,25 +0,0 @@
-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 IpcChildWithNodeForkedProcess
-    case IpcChildType.NodeWorker:
-      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,19 +0,0 @@
-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
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess
-  }
-  throw new Error(`[shared-process] unknown ipc type`)
-}

package/src/parts/JsonRpc/JsonRpc.js

@@ -1 +0,0 @@
-export * from '@lvce-editor/json-rpc'