@lvce-editor/test-with-playwright-worker 12.0.0 → 13.0.0

package/dist/workerMain.js

@@ -245,8 +245,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -269,14 +269,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -295,8 +295,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -306,8 +306,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -377,56 +377,14 @@ const IpcChildWithNodeWorker$1 = {
   wrap: wrap$b
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$1 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -622,7 +580,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -635,7 +593,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
 };
 const create = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
@@ -646,7 +604,7 @@ const getSuccessResponse = (message, result) => {
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -733,29 +691,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -778,24 +713,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -812,7 +810,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -830,7 +828,7 @@ const listen = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$7 = async ({
+const create$6 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -842,7 +840,7 @@ const create$7 = async ({
 };
 const NodeWorkerRpcClient = {
   __proto__: null,
-  create: create$7
+  create: create$6
 };
 
 const rpcs = Object.create(null);
@@ -918,23 +916,23 @@ const Fail = 3;
 
 const getTestState = (testOverlayState, text) => {
   switch (testOverlayState) {
-    case Pass$1:
+    case Fail$1:
       // @ts-ignore
       return {
-        status: Pass,
-        error: ''
+        error: `${text}`,
+        status: Fail
       };
-    case Skip$1:
+    case Pass$1:
       // @ts-ignore
       return {
-        status: Skip,
-        error: ''
+        error: '',
+        status: Pass
       };
-    case Fail$1:
+    case Skip$1:
       // @ts-ignore
       return {
-        status: Fail,
-        error: `${text}`
+        error: '',
+        status: Skip
       };
     default:
       throw new Error(`unexpected test state: ${testOverlayState}`);
@@ -944,21 +942,27 @@ const getTestState = (testOverlayState, text) => {
 /**
  * @param {string} absolutePath
  * @param {number} port
+ * @param {boolean} traceFocus
  */
-const getUrlFromTestFile = (absolutePath, port) => {
+const getUrlFromTestFile = (absolutePath, port, traceFocus) => {
   const baseName = basename(absolutePath);
   const htmlFileName = baseName.slice(0, -'.js'.length) + '.html';
-  return `http://localhost:${port}/tests/${htmlFileName}`;
+  const baseUrl = `http://localhost:${port}/tests/${htmlFileName}`;
+  if (traceFocus) {
+    return `${baseUrl}?traceFocus=true`;
+  }
+  return baseUrl;
 };
 const runTest = async ({
-  test,
   page,
-  testSrc,
   port,
-  timeout
+  test,
+  testSrc,
+  timeout,
+  traceFocus
 }) => {
   const start = performance.now();
-  const url = getUrlFromTestFile(test, port);
+  const url = getUrlFromTestFile(test, port, traceFocus);
   await page.goto(url, {
     waitUntil: 'networkidle'
   });
@@ -974,10 +978,10 @@ const runTest = async ({
   return {
     // @ts-ignore
     ...testState,
-    name: test,
-    start,
     end,
-    error: text
+    error: text,
+    name: test,
+    start
   };
 };
 
@@ -986,14 +990,15 @@ const runTest = async ({
  * @param {{testSrc:string, tests:string[], headless:boolean, page: import('@playwright/test').Page, port:number, timeout:number, onResult:any, onFinalResult:any}} param0
  */
 const runTests = async ({
-  testSrc,
-  tests,
   headless,
+  onFinalResult,
+  onResult,
   page,
   port,
+  tests,
+  testSrc,
   timeout,
-  onResult,
-  onFinalResult
+  traceFocus
 }) => {
   let failed = 0;
   let skipped = 0;
@@ -1001,11 +1006,12 @@ const runTests = async ({
   const start = performance.now();
   for (const test of tests) {
     const result = await runTest({
-      test,
       page,
-      testSrc,
       port,
-      timeout
+      test,
+      testSrc,
+      timeout,
+      traceFocus
     });
     await onResult(result);
     // @ts-ignore
@@ -1013,21 +1019,21 @@ const runTests = async ({
       case Fail:
         failed++;
         break;
-      case Skip:
-        skipped++;
-        break;
       case Pass:
         passed++;
         break;
+      case Skip:
+        skipped++;
+        break;
     }
   }
   const end = performance.now();
   await onFinalResult({
-    passed,
+    end,
     failed,
+    passed,
     skipped,
-    start,
-    end
+    start
   });
 };
 
@@ -1175,8 +1181,8 @@ const getServerPath = async serverPath => {
  * @returns
  */
 const startBrowser = async ({
-  signal,
-  headless
+  headless,
+  signal
 }) => {
   const browser = await chromium.launch({
     headless
@@ -1194,29 +1200,27 @@ const startBrowser = async ({
   };
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 /**
  *
  * @param {{signal:AbortSignal, port:number, serverPath:string, onlyExtension:string, testPath:string}} param0
  * @returns
  */
 const startServer = async ({
-  signal,
+  onlyExtension,
   port,
   serverPath,
-  onlyExtension,
+  signal,
   testPath
 }) => {
   const child = fork(serverPath, {
-    stdio: 'inherit',
     // signal,
     env: {
       ...process.env,
-      PORT: String(port),
       ONLY_EXTENSION: onlyExtension,
+      PORT: String(port),
       TEST_PATH: testPath
-    }
+    },
+    stdio: 'inherit'
   });
   child.on('error', x => {
     if (x.name === 'AbortError') {
@@ -1225,8 +1229,8 @@ const startServer = async ({
     console.log('child error', x);
   });
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   child.on('message', resolve);
   await promise;
@@ -1239,41 +1243,41 @@ const startServer = async ({
  * @returns
  */
 const setupTests = async ({
-  signal,
   headless,
   onlyExtension,
-  testPath,
-  serverPath
+  serverPath,
+  signal,
+  testPath
 }) => {
   const port = await getPort();
   const {
     browser,
     page
   } = await startBrowser({
-    signal,
-    headless
+    headless,
+    signal
   });
   const resolvedServerPath = await getServerPath(serverPath);
   const child = await startServer({
-    signal,
+    onlyExtension,
     port,
     serverPath: resolvedServerPath,
-    onlyExtension,
+    signal,
     testPath
   });
   return {
-    port,
     browser,
+    child,
     page,
-    child
+    port
   };
 };
 
 const SIGINT = 'SIGINT';
 
 const tearDownTests = async ({
-  controller,
-  child
+  child,
+  controller
 }) => {
   controller.abort();
   child.kill(SIGINT);
@@ -1284,9 +1288,11 @@ const tearDownTests = async ({
  * @param {string} testPath
  * @param {string} cwd
  * @param {boolean} headless
- * @param {number} headless
+ * @param {number} timeout
+ * @param {string} serverPath
+ * @param {boolean} traceFocus
  */
-const runAllTests = async (extensionPath, testPath, cwd, headless, timeout, serverPath) => {
+const runAllTests = async (extensionPath, testPath, cwd, headless, timeout, serverPath, traceFocus) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
@@ -1299,15 +1305,15 @@ const runAllTests = async (extensionPath, testPath, cwd, headless, timeout, serv
   } = controller;
   // @ts-ignore
   const {
-    page,
     child,
+    page,
     port
   } = await setupTests({
-    signal,
     headless,
     onlyExtension: extensionPath,
-    testPath,
-    serverPath
+    serverPath,
+    signal,
+    testPath
   });
   const testSrc = join(testPath, 'src');
   const tests = await getTests(testSrc);
@@ -1318,18 +1324,19 @@ const runAllTests = async (extensionPath, testPath, cwd, headless, timeout, serv
     await rpc.invoke(HandleFinalResult, finalResult);
   };
   await runTests({
-    testSrc,
-    tests,
     headless,
-    port,
+    onFinalResult,
+    onResult,
     page,
+    port,
+    tests,
+    testSrc,
     timeout,
-    onResult,
-    onFinalResult
+    traceFocus
   });
   await tearDownTests({
-    controller,
-    child
+    child,
+    controller
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "12.0.0",
+  "version": "13.0.0",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
   "type": "module",
   "main": "dist/workerMain.js",
   "dependencies": {
-    "@playwright/test": "1.57.0"
+    "@playwright/test": "1.58.0"
   },
   "engines": {
     "node": ">=22"