Upgrade Ava to v4

node_modules/ava/lib/plugin-support/shared-workers.js

@@ -1,14 +1,11 @@
-const events = require('events');
-const serializeError = require('../serialize-error');
+import events from 'node:events';
+import {pathToFileURL} from 'node:url';
+import {Worker} from 'node:worker_threads';
 
-let Worker;
-try {
-	({Worker} = require('worker_threads'));
-} catch {}
+import serializeError from '../serialize-error.js';
 
-const LOADER = require.resolve('./shared-worker-loader');
+const LOADER = new URL('shared-worker-loader.js', import.meta.url);
 
-let sharedWorkerCounter = 0;
 const launchedWorkers = new Map();
 
 const waitForAvailable = async worker => {
@@ -19,30 +16,28 @@ const waitForAvailable = async worker => {
 	}
 };
 
-function launchWorker({filename, initialData}) {
+function launchWorker(filename, initialData) {
 	if (launchedWorkers.has(filename)) {
 		return launchedWorkers.get(filename);
 	}
 
-	const id = `shared-worker/${++sharedWorkerCounter}`;
 	const worker = new Worker(LOADER, {
 		// Ensure the worker crashes for unhandled rejections, rather than allowing undefined behavior.
 		execArgv: ['--unhandled-rejections=strict'],
 		workerData: {
 			filename,
-			id,
-			initialData
-		}
+			initialData,
+		},
 	});
 	worker.setMaxListeners(0);
 
 	const launched = {
 		statePromises: {
 			available: waitForAvailable(worker),
-			error: events.once(worker, 'error').then(([error]) => error) // eslint-disable-line promise/prefer-await-to-then
+			error: events.once(worker, 'error').then(([error]) => error),
 		},
 		exited: false,
-		worker
+		worker,
 	};
 
 	launchedWorkers.set(filename, launched);
@@ -53,7 +48,7 @@ function launchWorker({filename, initialData}) {
 	return launched;
 }
 
-async function observeWorkerProcess(fork, runStatus) {
+export async function observeWorkerProcess(fork, runStatus) {
 	let registrationCount = 0;
 	let signalDeregistered;
 	const deregistered = new Promise(resolve => {
@@ -66,26 +61,11 @@ async function observeWorkerProcess(fork, runStatus) {
 		}
 	});
 
-	fork.onConnectSharedWorker(async channel => {
-		const launched = launchWorker(channel);
-
-		const handleChannelMessage = ({messageId, replyTo, serializedData}) => {
-			launched.worker.postMessage({
-				type: 'message',
-				testWorkerId: fork.forkId,
-				messageId,
-				replyTo,
-				serializedData
-			});
-		};
+	fork.onConnectSharedWorker(async ({filename, initialData, port, signalError}) => {
+		const launched = launchWorker(filename, initialData);
 
 		const handleWorkerMessage = async message => {
-			if (message.type === 'broadcast' || (message.type === 'message' && message.testWorkerId === fork.forkId)) {
-				const {messageId, replyTo, serializedData} = message;
-				channel.forwardMessageToFork({messageId, replyTo, serializedData});
-			}
-
-			if (message.type === 'deregistered-test-worker' && message.id === fork.forkId) {
+			if (message.type === 'deregistered-test-worker' && message.id === fork.threadId) {
 				launched.worker.off('message', handleWorkerMessage);
 
 				registrationCount--;
@@ -95,35 +75,35 @@ async function observeWorkerProcess(fork, runStatus) {
 			}
 		};
 
-		launched.statePromises.error.then(error => { // eslint-disable-line promise/prefer-await-to-then
+		launched.statePromises.error.then(error => {
 			signalDeregistered();
 			launched.worker.off('message', handleWorkerMessage);
 			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError('Shared worker error', true, error)});
-			channel.signalError();
+			signalError();
 		});
 
 		try {
 			await launched.statePromises.available;
 
 			registrationCount++;
+
+			port.postMessage({type: 'ready'});
+
 			launched.worker.postMessage({
 				type: 'register-test-worker',
-				id: fork.forkId,
-				file: fork.file
-			});
+				id: fork.threadId,
+				file: pathToFileURL(fork.file).toString(),
+				port,
+			}, [port]);
 
 			fork.promise.finally(() => {
 				launched.worker.postMessage({
 					type: 'deregister-test-worker',
-					id: fork.forkId
+					id: fork.threadId,
 				});
-
-				channel.off('message', handleChannelMessage);
 			});
 
 			launched.worker.on('message', handleWorkerMessage);
-			channel.on('message', handleChannelMessage);
-			channel.signalReady();
 		} catch {
 			return;
 		} finally {
@@ -136,5 +116,3 @@ async function observeWorkerProcess(fork, runStatus) {
 
 	return deregistered;
 }
-
-exports.observeWorkerProcess = observeWorkerProcess;