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

package/bin/test-with-playwright.js

@@ -1 +1,3 @@
-import '../src/parts/Cli/Cli.js'
+#!/usr/bin/env node
+
+import '../src/main.js'

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "1.7.0",
+  "version": "2.1.0",
   "description": "",
-  "main": "src/parts/RunAllTests/RunAllTests.js",
+  "main": "src/main.js",
   "type": "module",
   "bin": "bin/test-with-playwright.js",
   "repository": {
@@ -14,8 +14,12 @@
   "license": "MIT",
   "dependencies": {
     "@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",
     "minimist": "^1.2.8",
-    "@lvce-editor/test-with-playwright-worker": "1.7.0"
+    "@lvce-editor/test-with-playwright-worker": "2.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",

package/src/main.js

@@ -0,0 +1,3 @@
+import * as Main from './parts/Main/Main.js'
+
+Main.main()

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/HandleIpc/HandleIpc.js

@@ -1,15 +1,5 @@
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
+import * as HandleMessage from '../HandleMessage/HandleMessage.js'
 
-export function handleIpc(ipc) {
-  const handleMessage = async (message) => {
-    if ('result' in message || 'error' in message) {
-      Callback.resolve(message.id, message)
-      return
-    }
-    if ('method' in message) {
-      await Command.execute(message.method, ...message.params)
-    }
-  }
-  ipc.on('message', handleMessage)
+export const handleIpc = (ipc) => {
+  ipc.addEventListener('message', HandleMessage.handleMessage)
 }

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,26 @@
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+const prepare = (error) => {
+  return error
+}
+
+const requiresSocket = (method) => {
+  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/IpcParent/IpcParent.js

@@ -1,7 +1,7 @@
 import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js'
 
 export const create = async ({ method, ...options }) => {
-  const module = await IpcParentModule.getModule(method)
+  const module = IpcParentModule.getModule(method)
   // @ts-ignore
   const rawIpc = await module.create(options)
   const ipc = module.wrap(rawIpc)

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -1,9 +1,10 @@
 import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import { IpcParentWithNodeWorker } from '@lvce-editor/ipc'
 
 export const getModule = (method) => {
   switch (method) {
     case IpcParentType.NodeWorker:
-      return import('../IpcParentWithNodeWorker/IpcParentWithNodeWorker.js')
+      return IpcParentWithNodeWorker
     default:
       throw new Error('unexpected ipc type')
   }

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/{Cli/Cli.js → Main/Main.js}

@@ -1,13 +1,11 @@
+import * as Command from '../Command/Command.js'
+import * as CommandMap from '../CommandMap/CommandMap.js'
 import * as HandleCliArgs from '../HandleCliArgs/HandleCliArgs.js'
 import * as Process from '../Process/Process.js'
 import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
-import * as CommandState from '../CommandState/CommandState.js'
-import * as CommandMap from '../CommandMap/CommandMap.js'
 
 export const main = () => {
   Process.on('uncaughtExceptionMonitor', ProcessListeners.handleUncaughtExceptionMonitor)
-  CommandState.registerCommands(CommandMap.commandMap)
+  Command.register(CommandMap.commandMap)
   HandleCliArgs.handleCliArgs({ argv: Process.argv, env: Process.env })
 }
-
-main()

package/src/parts/Assert/Assert.js

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

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/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/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -1,5 +0,0 @@
-export const Exit = 'exit'
-
-export const Error = 'error'
-
-export const Message = 'message'

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -1,28 +0,0 @@
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-
-export const getFirstNodeWorkerEvent = async (worker) => {
-  const { type, event } = await new Promise((resolve, reject) => {
-    const cleanup = (value) => {
-      worker.off('message', handleMessage)
-      worker.off('exit', handleExit)
-      worker.off('error', handleError)
-      resolve(value)
-    }
-    const handleMessage = (event) => {
-      cleanup({
-        type: FirstNodeWorkerEventType.Message,
-        event,
-      })
-    }
-    const handleExit = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Exit, event })
-    }
-    const handleError = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Error, event })
-    }
-    worker.on('message', handleMessage)
-    worker.on('exit', handleExit)
-    worker.on('error', handleError)
-  })
-  return { type, event }
-}

package/src/parts/GetPort/GetPort.js

@@ -1,5 +0,0 @@
-import _getPort from 'get-port'
-
-export const getPort = () => {
-  return _getPort()
-}

package/src/parts/GetTests/GetTests.js

@@ -1,9 +0,0 @@
-import { readdir } from 'fs/promises'
-
-/**
- * @param {string} testSrc
- */
-export const getTests = async (testSrc) => {
-  const dirents = await readdir(testSrc)
-  return dirents
-}

package/src/parts/Id/Id.js

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

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/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -1,41 +0,0 @@
-import { Worker } from 'node:worker_threads'
-import * as Assert from '../Assert/Assert.js'
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-import * as GetFirstNodeWorkerEvent from '../GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js'
-import { IpcError } from '../IpcError/IpcError.js'
-
-export const create = async ({ path, argv, env, execArgv }) => {
-  Assert.string(path)
-  const actualArgv = ['--ipc-type=node-worker', ...argv]
-  const worker = new Worker(path, {
-    argv: actualArgv,
-    env,
-    execArgv,
-  })
-  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
-  if (type === FirstNodeWorkerEventType.Error) {
-    throw event
-  }
-  if (type === FirstNodeWorkerEventType.Exit) {
-    throw new IpcError('worker exited unexpectedly')
-  }
-  return worker
-}
-
-export const wrap = (worker) => {
-  return {
-    worker,
-    on(event, listener) {
-      this.worker.on(event, listener)
-    },
-    send(message) {
-      this.worker.postMessage(message)
-    },
-    sendAndTransfer(message, transfer) {
-      this.worker.postMessage(message, transfer)
-    },
-    dispose() {
-      this.worker.terminate()
-    },
-  }
-}

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

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

package/src/parts/Signal/Signal.js

@@ -1 +0,0 @@
-export const SIGINT = 'SIGINT'