ava 3.15.0 → 4.0.0

package/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;

package/lib/provider-manager.js

@@ -1,21 +1,21 @@
-const pkg = require('../package.json');
-const globs = require('./globs');
+import * as globs from './globs.js';
+import pkg from './pkg.cjs';
 
 const levels = {
-	ava3: 1,
-	pathRewrites: 2
+	// As the protocol changes, comparing levels by integer allows AVA to be
+	// compatible with different versions. Currently there is only one supported
+	// version, so this is effectively unused. The infrastructure is retained for
+	// future use.
+	levelIntegersAreCurrentlyUnused: 0,
 };
 
-exports.levels = levels;
-
 const levelsByProtocol = {
-	'ava-3': levels.ava3,
-	'ava-3.2': levels.pathRewrites
+	'ava-3.2': levels.levelIntegersAreCurrentlyUnused,
 };
 
-function load(providerModule, projectDir) {
+async function load(providerModule, projectDir) {
 	const ava = {version: pkg.version};
-	const makeProvider = require(providerModule);
+	const {default: makeProvider} = await import(providerModule); // eslint-disable-line node/no-unsupported-features/es-syntax
 
 	let fatal;
 	let level;
@@ -37,9 +37,9 @@ function load(providerModule, projectDir) {
 				},
 				identifier,
 				normalizeGlobPatterns: globs.normalizePatterns,
-				projectDir
+				projectDir,
 			};
-		}
+		},
 	});
 
 	if (fatal) {
@@ -49,5 +49,11 @@ function load(providerModule, projectDir) {
 	return {...provider, level};
 }
 
-exports.babel = projectDir => load('@ava/babel', projectDir);
-exports.typescript = projectDir => load('@ava/typescript', projectDir);
+const providerManager = {
+	levels,
+	async typescript(projectDir) {
+		return load('@ava/typescript', projectDir);
+	},
+};
+
+export default providerManager;

package/lib/reporters/beautify-stack.js

@@ -1,16 +1,10 @@
-'use strict';
-const StackUtils = require('stack-utils');
+import StackUtils from 'stack-utils';
 
 const stackUtils = new StackUtils({
 	ignoredPackages: [
-		'@ava/babel',
-		'@ava/require-precompiled',
 		'@ava/typescript',
-		'append-transform',
 		'ava',
-		'empower-core',
-		'esm',
-		'nyc'
+		'nyc',
 	],
 	internals: [
 		// AVA internals, which ignoredPackages don't ignore when we run our own unit tests.
@@ -20,8 +14,8 @@ const stackUtils = new StackUtils({
 		/\(internal\/process\/task_queues\.js:\d+:\d+\)$/,
 		/\(internal\/modules\/cjs\/.+?\.js:\d+:\d+\)$/,
 		/async Promise\.all \(index/,
-		/new Promise \(<anonymous>\)/
-	]
+		/new Promise \(<anonymous>\)/,
+	],
 });
 
 /*
@@ -60,7 +54,7 @@ const stackUtils = new StackUtils({
  * Module.runMain (module.js:604:10)
  * ```
  */
-module.exports = stack => {
+export default function beautifyStack(stack) {
 	if (!stack) {
 		return [];
 	}
@@ -70,4 +64,4 @@ module.exports = stack => {
 		.split('\n')
 		.map(line => line.trim())
 		.filter(line => line !== '');
-};
+}

package/lib/reporters/colors.js

@@ -1,17 +1,42 @@
-'use strict';
-const chalk = require('../chalk').get();
+import {chalk} from '../chalk.js';
 
-module.exports = {
-	log: chalk.gray,
-	title: chalk.bold,
-	error: chalk.red,
-	skip: chalk.yellow,
-	todo: chalk.blue,
-	pass: chalk.green,
-	duration: chalk.gray.dim,
-	errorSource: chalk.gray,
-	errorStack: chalk.gray,
-	errorStackInternal: chalk.gray.dim,
-	stack: chalk.red,
-	information: chalk.magenta
+const colors = {
+	get log() {
+		return chalk.gray;
+	},
+	get title() {
+		return chalk.bold;
+	},
+	get error() {
+		return chalk.red;
+	},
+	get skip() {
+		return chalk.yellow;
+	},
+	get todo() {
+		return chalk.blue;
+	},
+	get pass() {
+		return chalk.green;
+	},
+	get duration() {
+		return chalk.gray.dim;
+	},
+	get errorSource() {
+		return chalk.gray;
+	},
+	get errorStack() {
+		return chalk.gray;
+	},
+	get errorStackInternal() {
+		return chalk.gray.dim;
+	},
+	get stack() {
+		return chalk.red;
+	},
+	get information() {
+		return chalk.magenta;
+	},
 };
+
+export default colors;