@systemfsoftware/stryker-js-typescript-checker 0.1.0

package/dist/index.mjs

@@ -0,0 +1,602 @@
+import { readFileSync } from "fs";
+import { PluginKind, Scope, commonTokens, declareFactoryPlugin, tokens } from "@stryker-mutator/api/plugin";
+import { EOL } from "os";
+import { CheckStatus } from "@stryker-mutator/api/check";
+import { split, strykerReportBugUrl } from "@stryker-mutator/util";
+import { API, DiagnosticCategory } from "typescript/unstable/sync";
+import { createRequire } from "module";
+import path from "path";
+import semver from "semver";
+import { SyntaxKind } from "typescript/unstable/ast";
+//#region src/tsconfig-helpers.ts
+const COMPILER_OPTIONS_OVERRIDES = Object.freeze({
+	allowUnreachableCode: true,
+	noUnusedLocals: false,
+	noUnusedParameters: false
+});
+const NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT = Object.freeze({
+	noEmit: true,
+	incremental: false,
+	tsBuildInfoFile: void 0,
+	composite: false
+});
+const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES = Object.freeze({
+	emitDeclarationOnly: true,
+	noEmit: false,
+	declarationMap: true,
+	declaration: true
+});
+let cachedTSVersion;
+function getTSVersion() {
+	if (cachedTSVersion === void 0) {
+		const require = createRequire(import.meta.url);
+		cachedTSVersion = JSON.parse(readFileSync(require.resolve("typescript/package.json"), "utf-8")).version;
+	}
+	return cachedTSVersion;
+}
+function guardTSVersion(version = getTSVersion()) {
+	if (!semver.satisfies(version, ">=7.0.0", { includePrerelease: true })) throw new Error(`@systemfsoftware/stryker-js-typescript-checker only supports typescript@7.0.0 or higher. Found typescript@${version}`);
+}
+function stripJsonComments(json) {
+	return json.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+}
+function parseConfigFileTextToJson(fileName, jsonText) {
+	try {
+		const stripped = stripJsonComments(jsonText);
+		return { config: JSON.parse(stripped) };
+	} catch (error) {
+		return { error };
+	}
+}
+function determineBuildModeEnabled(tsconfigFileName) {
+	const parsed = parseConfigFileTextToJson(tsconfigFileName, readFileSync(tsconfigFileName, "utf-8"));
+	if (parsed.error) return false;
+	return "references" in parsed.config;
+}
+/**
+* Overrides some options to speed up compilation and disable some code quality checks we don't want during mutation testing
+* @param parsedConfig The parsed config file
+* @param useBuildMode whether or not `--build` mode is used
+*/
+function overrideOptions(parsedConfig, useBuildMode) {
+	const config = parsedConfig.config ?? {};
+	const compilerOptions = {
+		...config.compilerOptions,
+		...COMPILER_OPTIONS_OVERRIDES,
+		...useBuildMode ? LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES : NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT,
+		target: "es2022",
+		moduleResolution: "bundler"
+	};
+	if (!useBuildMode && compilerOptions["declarationDir"] !== void 0 && compilerOptions["declarationDir"] !== null) delete compilerOptions["declarationDir"];
+	if (useBuildMode) {
+		delete compilerOptions["inlineSourceMap"];
+		delete compilerOptions["inlineSources"];
+		delete compilerOptions["mapRoute"];
+		delete compilerOptions["sourceRoot"];
+		delete compilerOptions["outFile"];
+	}
+	return JSON.stringify({
+		...config,
+		compilerOptions
+	});
+}
+/**
+* Retrieves the referenced config files based on parsed configuration
+* @param parsedConfig The parsed config file
+* @param fromDirName The directory where to resolve from
+*/
+function retrieveReferencedProjects(parsedConfig, fromDirName) {
+	const config = parsedConfig.config;
+	if (Array.isArray(config?.references)) return config.references.map((reference) => {
+		let resolved = path.resolve(fromDirName, reference.path);
+		if (!path.basename(resolved).endsWith(".json")) resolved = path.join(resolved, "tsconfig.json");
+		return toPosixFileName(resolved);
+	});
+	return [];
+}
+/**
+* Replaces backslashes with forward slashes (used by typescript)
+* @param fileName The file name that may contain backslashes `\`
+* @returns posix and ts complaint file name (with `/`)
+*/
+function toPosixFileName(fileName) {
+	return fileName.replace(/\\/g, "/");
+}
+/**
+* Find source file in declaration file
+* @param content The content of the declaration file
+* @returns URL of the source file or undefined if not found
+*/
+const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m;
+function getSourceMappingURL(content) {
+	findSourceMapRegex.lastIndex = 0;
+	return findSourceMapRegex.exec(content)?.[1];
+}
+//#endregion
+//#region src/fs/script-file.ts
+var ScriptFile = class {
+	content;
+	fileName;
+	modifiedTime;
+	originalContent;
+	constructor(content, fileName, modifiedTime = /* @__PURE__ */ new Date()) {
+		this.content = content;
+		this.fileName = fileName;
+		this.modifiedTime = modifiedTime;
+		this.originalContent = content;
+	}
+	write(content) {
+		this.content = content;
+		this.touch();
+	}
+	mutate(mutant) {
+		const start = this.getOffset(mutant.location.start);
+		const end = this.getOffset(mutant.location.end);
+		this.content = `${this.originalContent.slice(0, start)}${mutant.replacement}${this.originalContent.slice(end)}`;
+		this.touch();
+	}
+	getOffset(pos) {
+		const lines = this.originalContent.split("\n");
+		let offset = 0;
+		for (let i = 0; i < pos.line && i < lines.length; i++) offset += lines[i].length + 1;
+		offset += pos.column;
+		return offset;
+	}
+	resetMutant() {
+		this.content = this.originalContent;
+		this.touch();
+	}
+	touch() {
+		this.modifiedTime = /* @__PURE__ */ new Date();
+	}
+};
+//#endregion
+//#region src/fs/hybrid-file-system.ts
+/**
+* A very simple hybrid file system.
+* * Readonly from disk
+* * Writes in-memory
+* * Hard caching
+* * Ability to mutate one file
+*/
+var HybridFileSystem = class {
+	files = /* @__PURE__ */ new Map();
+	/**
+	* Map of absolute tsconfig file paths to their adjusted JSON content.
+	* This allows the TS7 API to read overridden compiler options.
+	*/
+	tsConfigOverrides = /* @__PURE__ */ new Map();
+	readFile = (fileName) => {
+		const normalized = toPosixFileName(fileName);
+		if (this.fileNameIsBuildInfo(normalized)) return null;
+		const override = this.tsConfigOverrides.get(normalized);
+		if (override !== void 0) return override;
+		const file = this.files.get(normalized);
+		if (file) return file.content;
+		if (file === void 0 && this.files.has(normalized)) return null;
+	};
+	fileExists = (fileName) => {
+		const normalized = toPosixFileName(fileName);
+		if (this.fileNameIsBuildInfo(normalized)) return false;
+		if (this.tsConfigOverrides.has(normalized)) return true;
+		if (this.files.has(normalized)) return this.files.get(normalized) !== void 0;
+	};
+	directoryExists = () => {};
+	getAccessibleEntries = () => {};
+	realpath = () => {};
+	writeFile(fileName, data) {
+		const normalized = toPosixFileName(fileName);
+		const existingFile = this.files.get(normalized);
+		if (existingFile) existingFile.write(data);
+		else this.files.set(normalized, new ScriptFile(data, normalized));
+	}
+	getFile(fileName) {
+		const normalized = toPosixFileName(fileName);
+		if (!this.files.has(normalized)) try {
+			const content = readFileSync(normalized, "utf-8");
+			this.files.set(normalized, new ScriptFile(content, normalized));
+		} catch {
+			this.files.set(normalized, void 0);
+		}
+		return this.files.get(normalized);
+	}
+	mutateFile(fileName, mutant) {
+		const file = this.getFile(fileName);
+		if (!file) throw new Error(`Tried to mutate file "${fileName}" but it could not be found.`);
+		file.mutate(mutant);
+	}
+	resetFile(fileName) {
+		this.getFile(fileName)?.resetMutant();
+	}
+	existsInMemory(fileName) {
+		return this.files.get(toPosixFileName(fileName)) !== void 0;
+	}
+	fileNameIsBuildInfo(fileName) {
+		return fileName.endsWith(".tsbuildinfo");
+	}
+};
+//#endregion
+//#region src/grouping/ts-file-node.ts
+var TSFileNode = class {
+	fileName;
+	parents;
+	children;
+	constructor(fileName, parents, children) {
+		this.fileName = fileName;
+		this.parents = parents;
+		this.children = children;
+	}
+	getAllParentReferencesIncludingSelf(allParentReferences = /* @__PURE__ */ new Set()) {
+		allParentReferences.add(this);
+		this.parents.forEach((parent) => {
+			if (!allParentReferences.has(parent)) parent.getAllParentReferencesIncludingSelf(allParentReferences);
+		});
+		return allParentReferences;
+	}
+	getAllChildReferencesIncludingSelf(allChildReferences = /* @__PURE__ */ new Set()) {
+		allChildReferences.add(this);
+		this.children.forEach((child) => {
+			if (!allChildReferences.has(child)) child.getAllChildReferencesIncludingSelf(allChildReferences);
+		});
+		return allChildReferences;
+	}
+	getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked = []) {
+		if (nodesChecked.includes(this.fileName)) return [];
+		nodesChecked.push(this.fileName);
+		const relatedMutants = mutants.filter((m) => toPosixFileName(m.fileName) === this.fileName);
+		const childResult = this.children.flatMap((c) => c.getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked));
+		return [...relatedMutants, ...childResult];
+	}
+};
+//#endregion
+//#region src/grouping/create-groups.ts
+/**
+* To speed up the type-checking we want to check multiple mutants at once.
+* When multiple mutants in different files don't have overlap in affected files (or have small overlap), we can type-check them simultaneously.
+* These mutants who can be tested at the same time are called a group.
+* Therefore, the return type is an array of arrays, in other words: an array of groups.
+*
+* @param mutants All the mutants of the test project.
+* @param nodes A graph representation of the test project.
+*/
+function createGroups(mutants, nodes) {
+	const groups = [];
+	const mutantsToGroup = new Set(mutants);
+	while (mutantsToGroup.size) {
+		const group = [];
+		const groupNodes = /* @__PURE__ */ new Set();
+		const nodesToIgnore = /* @__PURE__ */ new Set();
+		for (const currentMutant of mutantsToGroup) {
+			const currentNode = findNode(currentMutant.fileName, nodes);
+			if (!nodesToIgnore.has(currentNode) && !parentsHaveOverlapWith(currentNode, groupNodes)) {
+				group.push(currentMutant.id);
+				groupNodes.add(currentNode);
+				mutantsToGroup.delete(currentMutant);
+				addRangeOfNodesToSet(nodesToIgnore, currentNode.getAllParentReferencesIncludingSelf());
+			}
+		}
+		groups.push(group);
+	}
+	return groups;
+}
+function addRangeOfNodesToSet(nodes, nodesToAdd) {
+	for (const parent of nodesToAdd) nodes.add(parent);
+}
+function findNode(fileName, nodes) {
+	const node = nodes.get(toPosixFileName(fileName));
+	if (node == null) throw new Error(`Node not in graph: ${fileName}`);
+	return node;
+}
+function parentsHaveOverlapWith(currentNode, groupNodes) {
+	for (const parentNode of currentNode.getAllParentReferencesIncludingSelf()) if (groupNodes.has(parentNode)) return true;
+	return false;
+}
+const tsCompiler = "tsCompiler";
+//#endregion
+//#region src/typescript-compiler.ts
+var TypescriptCompiler = class {
+	log;
+	options;
+	fs;
+	static inject = tokens(commonTokens.logger, commonTokens.options, "fs");
+	allTSConfigFiles;
+	tsconfigFile;
+	api;
+	snapshot;
+	sourceFiles = /* @__PURE__ */ new Map();
+	_nodes = /* @__PURE__ */ new Map();
+	lastMutants = [];
+	lastMutatedFileNames = [];
+	constructor(log, options, fs) {
+		this.log = log;
+		this.options = options;
+		this.fs = fs;
+		this.tsconfigFile = toPosixFileName(path.resolve(toPosixFileName(this.options.tsconfigFile)));
+		this.allTSConfigFiles = /* @__PURE__ */ new Set([this.tsconfigFile]);
+	}
+	async init() {
+		guardTSVersion();
+		this.guardTSConfigFileExists();
+		const buildModeEnabled = determineBuildModeEnabled(this.tsconfigFile);
+		this.collectAllTSConfigFiles(buildModeEnabled);
+		this.api = new API({ fs: this.fs });
+		this.snapshot = this.api.updateSnapshot({ openProjects: [...this.allTSConfigFiles] });
+		const programs = this.getPrograms();
+		this.buildDependencyGraph(programs);
+		return this.check([]);
+	}
+	async check(mutants) {
+		for (const mutant of this.lastMutants) this.fs.resetFile(mutant.fileName);
+		for (const mutant of mutants) {
+			const file = this.fs.getFile(mutant.fileName);
+			if (!file) throw new Error(`Tried to check file "${mutant.fileName}" (which is part of your typescript project), but it could not be found.`);
+			file.mutate(mutant);
+		}
+		const mutatedFileNames = [...new Set(mutants.map((m) => toPosixFileName(m.fileName)))];
+		const changedFiles = [.../* @__PURE__ */ new Set([...this.lastMutatedFileNames, ...mutatedFileNames])];
+		if (this.api && this.snapshot) {
+			const oldSnapshot = this.snapshot;
+			this.snapshot = this.api.updateSnapshot({
+				openProjects: [...this.allTSConfigFiles],
+				fileChanges: { changed: changedFiles }
+			});
+			oldSnapshot.dispose();
+		}
+		this.lastMutants = mutants;
+		this.lastMutatedFileNames = mutatedFileNames;
+		return this.getPrograms().flatMap((program) => [
+			...program.getConfigFileParsingDiagnostics(),
+			...program.getSemanticDiagnostics(),
+			...program.getProgramDiagnostics()
+		]);
+	}
+	get nodes() {
+		if (!this._nodes.size) {
+			for (const [fileName] of this.sourceFiles) {
+				const node = new TSFileNode(fileName, [], []);
+				this._nodes.set(fileName, node);
+			}
+			for (const [fileName, file] of this.sourceFiles) {
+				const node = this._nodes.get(fileName);
+				if (node == null) throw new Error(`Node for file '${fileName}' could not be found. This should not happen.`);
+				node.children = [...file.imports].map((importName) => this._nodes.get(importName)).filter((n) => n != null);
+			}
+			for (const [, node] of this._nodes) {
+				node.parents = [];
+				for (const [, n] of this._nodes) if (n.children.includes(node)) node.parents.push(n);
+			}
+		}
+		return this._nodes;
+	}
+	close() {
+		this.snapshot?.dispose();
+		this.api?.close();
+	}
+	getLineAndCharacterOfPosition(fileName, position) {
+		for (const program of this.getPrograms()) {
+			const sourceFile = program.getSourceFile(fileName);
+			if (sourceFile) return sourceFile.getLineAndCharacterOfPosition(position);
+		}
+	}
+	getPrograms() {
+		if (!this.snapshot) throw new Error("TypescriptCompiler not initialized");
+		const projects = this.snapshot.getProjects();
+		if (projects.length === 0) throw new Error(`No projects found for ${this.tsconfigFile}`);
+		return projects.map((project) => project.program);
+	}
+	collectAllTSConfigFiles(buildModeEnabled) {
+		const tsConfigOverrides = /* @__PURE__ */ new Map();
+		const toProcess = [this.tsconfigFile];
+		const processed = /* @__PURE__ */ new Set();
+		while (toProcess.length > 0) {
+			const current = toProcess.pop();
+			if (!current || processed.has(current)) continue;
+			processed.add(current);
+			const content = readFileSync(current, "utf-8");
+			const parsed = parseConfigFileTextToJson(current, content);
+			if (parsed.error) {
+				tsConfigOverrides.set(current, content);
+				continue;
+			}
+			tsConfigOverrides.set(current, overrideOptions(parsed, buildModeEnabled));
+			for (const referenced of retrieveReferencedProjects(parsed, path.dirname(current))) {
+				this.allTSConfigFiles.add(referenced);
+				toProcess.push(referenced);
+			}
+		}
+		this.fs.tsConfigOverrides = tsConfigOverrides;
+	}
+	buildDependencyGraph(programs) {
+		for (const program of programs) for (const fileName of program.getSourceFileNames()) {
+			if (fileName.endsWith(".d.ts") || fileName.includes("node_modules")) continue;
+			const normalized = toPosixFileName(fileName);
+			this.sourceFiles.set(normalized, {
+				fileName: normalized,
+				imports: /* @__PURE__ */ new Set()
+			});
+		}
+		for (const [fileName] of this.sourceFiles) {
+			const sourceFile = programs.map((p) => p.getSourceFile(fileName)).find((sf) => sf != null);
+			if (!sourceFile) continue;
+			const imports = this.extractImports(sourceFile);
+			for (const specifier of imports) {
+				const resolved = this.resolveModuleSpecifier(fileName, specifier);
+				if (resolved) {
+					const sourceFileName = this.resolveTSInputFile(resolved);
+					if (this.sourceFiles.has(sourceFileName)) this.sourceFiles.get(fileName)?.imports.add(sourceFileName);
+				}
+			}
+		}
+	}
+	extractImports(sourceFile) {
+		const result = [];
+		for (const statement of sourceFile.statements) if (statement.kind === SyntaxKind.ImportDeclaration) {
+			let spec;
+			statement.forEachChild((child) => {
+				if (child.kind === SyntaxKind.StringLiteral) spec = child;
+			});
+			if (spec) result.push(spec.getText(sourceFile));
+		} else if (statement.kind === SyntaxKind.ImportEqualsDeclaration) statement.forEachChild((child) => {
+			if (child.kind === SyntaxKind.ExternalModuleReference) child.forEachChild((refChild) => {
+				if (refChild.kind === SyntaxKind.StringLiteral) result.push(refChild.getText(sourceFile));
+			});
+		});
+		for (const ref of sourceFile.referencedFiles) result.push(ref.fileName);
+		for (const ref of sourceFile.typeReferenceDirectives) result.push(ref.fileName);
+		return result;
+	}
+	resolveModuleSpecifier(sourceFileName, specifier) {
+		const cleaned = specifier.replace(/^['"]|['"]$/g, "");
+		if (!cleaned.startsWith("./") && !cleaned.startsWith("../")) return;
+		const baseDir = path.dirname(sourceFileName);
+		const resolved = toPosixFileName(path.resolve(baseDir, cleaned));
+		const candidates = this.getResolutionCandidates(resolved);
+		for (const candidate of candidates) if (this.sourceFiles.has(candidate)) return candidate;
+	}
+	getResolutionCandidates(resolved) {
+		const extension = path.extname(resolved);
+		if (extension) {
+			const withoutExt = resolved.slice(0, -extension.length);
+			return [
+				resolved,
+				`${withoutExt}.ts`,
+				`${withoutExt}.tsx`,
+				`${withoutExt}.d.ts`,
+				`${withoutExt}.js`,
+				`${withoutExt}.jsx`,
+				`${withoutExt}.mjs`,
+				`${withoutExt}.cjs`
+			];
+		}
+		return [
+			resolved,
+			`${resolved}.ts`,
+			`${resolved}.tsx`,
+			`${resolved}.d.ts`,
+			`${resolved}/index.ts`,
+			`${resolved}/index.tsx`,
+			`${resolved}/index.d.ts`,
+			`${resolved}.js`,
+			`${resolved}.jsx`,
+			`${resolved}.mjs`,
+			`${resolved}.cjs`,
+			`${resolved}/index.js`,
+			`${resolved}/index.jsx`,
+			`${resolved}/index.mjs`,
+			`${resolved}/index.cjs`
+		];
+	}
+	resolveTSInputFile(dependencyFileName) {
+		if (!dependencyFileName.endsWith(".d.ts")) return dependencyFileName;
+		const file = this.fs.getFile(dependencyFileName);
+		if (!file) return dependencyFileName;
+		const sourceMappingURL = getSourceMappingURL(file.content);
+		if (!sourceMappingURL) return dependencyFileName;
+		const sourceMapFileName = toPosixFileName(path.resolve(path.dirname(dependencyFileName), sourceMappingURL));
+		const sourceMap = this.fs.getFile(sourceMapFileName);
+		if (!sourceMap) {
+			this.log.warn(`Could not find sourcemap ${sourceMapFileName}`);
+			return dependencyFileName;
+		}
+		const sources = JSON.parse(sourceMap.content).sources;
+		if (sources?.length === 1) {
+			const [sourcePath] = sources;
+			return toPosixFileName(path.resolve(path.dirname(sourceMapFileName), sourcePath));
+		}
+		return dependencyFileName;
+	}
+	guardTSConfigFileExists() {
+		try {
+			readFileSync(this.tsconfigFile, "utf-8");
+		} catch {
+			throw new Error(`The tsconfig file does not exist at: "${this.tsconfigFile}". Please configure the tsconfig file in your stryker.conf file using "tsconfigFile"`);
+		}
+	}
+};
+//#endregion
+//#region src/typescript-checker.ts
+const typescriptCheckerLoggerFactory = Object.assign((loggerFactory, target) => {
+	const targetName = target?.name ?? TypescriptChecker.name;
+	return loggerFactory(targetName === TypescriptChecker.name ? TypescriptChecker.name : `${TypescriptChecker.name}.${targetName}`);
+}, { inject: tokens(commonTokens.getLogger, commonTokens.target) });
+const create = Object.assign((injector) => injector.provideFactory(commonTokens.logger, typescriptCheckerLoggerFactory, Scope.Transient).provideClass("fs", HybridFileSystem).provideClass(tsCompiler, TypescriptCompiler).injectClass(TypescriptChecker), { inject: tokens(commonTokens.injector) });
+var TypescriptChecker = class {
+	logger;
+	tsCompiler;
+	static inject = tokens(commonTokens.logger, commonTokens.options, tsCompiler);
+	options;
+	constructor(logger, options, tsCompiler) {
+		this.logger = logger;
+		this.tsCompiler = tsCompiler;
+		this.options = options;
+	}
+	async init() {
+		const errors = await this.tsCompiler.init();
+		if (errors.length) throw new Error(`Typescript error(s) found in dry run compilation: ${this.createErrorText(errors)}`);
+	}
+	async check(mutants) {
+		const result = Object.fromEntries(mutants.map((mutant) => [mutant.id, { status: CheckStatus.Passed }]));
+		if (!this.tsCompiler.nodes.get(toPosixFileName(mutants[0].fileName))) return result;
+		const mutantErrorRelationMap = await this.checkErrors(mutants, {}, this.tsCompiler.nodes);
+		for (const [id, errors] of Object.entries(mutantErrorRelationMap)) result[id] = {
+			status: CheckStatus.CompileError,
+			reason: this.createErrorText(errors)
+		};
+		return result;
+	}
+	group(mutants) {
+		if (!this.options.typescriptChecker?.prioritizePerformanceOverAccuracy) return Promise.resolve(mutants.map((m) => [m.id]));
+		const { nodes } = this.tsCompiler;
+		const [mutantsOutsideProject, mutantsInProject] = split(mutants, (m) => nodes.get(toPosixFileName(m.fileName)) == null);
+		const groups = createGroups(mutantsInProject, nodes);
+		if (mutantsOutsideProject.length) return Promise.resolve([mutantsOutsideProject.map((m) => m.id), ...groups]);
+		else return Promise.resolve(groups);
+	}
+	async checkErrors(mutants, errorsMap, nodes) {
+		const errors = await this.tsCompiler.check(mutants);
+		const mutantsThatCouldNotBeTestedInGroups = /* @__PURE__ */ new Set();
+		if (errors.length && mutants.length === 1) {
+			errorsMap[mutants[0].id] = errors;
+			return errorsMap;
+		}
+		for (const error of errors) {
+			if (!error.fileName) throw new Error(`Typescript error: '${error.text}' was reported without a corresponding file. This shouldn't happen. Please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error without a corresponding file: ${error.text}`)}`);
+			const nodeErrorWasThrownIn = nodes.get(error.fileName);
+			if (!nodeErrorWasThrownIn) throw new Error(`Typescript error: '${error.text}' was reported in an unrelated file (${error.fileName}). This file is not part of your project, or referenced from your project. This shouldn't happen, please open an issue using this link: ${strykerReportBugUrl(`[BUG]: TypeScript checker reports compile error in an unrelated file: ${error.text}`)}`);
+			const mutantsRelatedToError = nodeErrorWasThrownIn.getMutantsWithReferenceToChildrenOrSelf(mutants);
+			if (mutantsRelatedToError.length === 0) for (const mutant of mutants) mutantsThatCouldNotBeTestedInGroups.add(mutant);
+			else if (mutantsRelatedToError.length === 1) {
+				const mutantId = mutantsRelatedToError[0].id;
+				if (errorsMap[mutantId]) errorsMap[mutantId].push(error);
+				else errorsMap[mutantId] = [error];
+			} else for (const mutant of mutantsRelatedToError) mutantsThatCouldNotBeTestedInGroups.add(mutant);
+		}
+		if (mutantsThatCouldNotBeTestedInGroups.size) await this.tsCompiler.check([]);
+		for (const mutant of mutantsThatCouldNotBeTestedInGroups) {
+			if (errorsMap[mutant.id]) continue;
+			await this.checkErrors([mutant], errorsMap, nodes);
+		}
+		return errorsMap;
+	}
+	createErrorText(errors) {
+		return errors.map((error) => this.formatDiagnostic(error)).join(EOL);
+	}
+	formatDiagnostic(error) {
+		const severity = error.category === DiagnosticCategory.Error ? "error" : error.category === DiagnosticCategory.Warning ? "warning" : error.category === DiagnosticCategory.Suggestion ? "suggestion" : "message";
+		let location = "";
+		if (error.fileName) {
+			const lineAndCharacter = this.tsCompiler.getLineAndCharacterOfPosition(error.fileName, error.pos);
+			const line = (lineAndCharacter?.line ?? 0) + 1;
+			const character = (lineAndCharacter?.character ?? 0) + 1;
+			location = `${error.fileName}(${line},${character}): `;
+		}
+		return `${location}${severity} TS${error.code}: ${error.text}`;
+	}
+};
+//#endregion
+//#region src/index.ts
+const strykerPlugins = [declareFactoryPlugin(PluginKind.Checker, "typescript", create)];
+const createTypescriptChecker = create;
+const strykerValidationSchema = JSON.parse(readFileSync(new URL("../schema/typescript-checker-options.json", import.meta.url), "utf-8"));
+//#endregion
+export { createTypescriptChecker, strykerPlugins, strykerValidationSchema };

package/oxlint.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'oxlint'
+
+export default defineConfig({
+  rules: {
+    // TypeScript already reports unused locals; avoids false positives in test files.
+    'no-unused-vars': 'off',
+  },
+  ignorePatterns: ['**/testResources/**'],
+})

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@systemfsoftware/stryker-js-typescript-checker",
+  "version": "0.1.0",
+  "description": "TypeScript checker plugin for Stryker — TS7 native",
+  "type": "module",
+  "exports": {
+    ".": {
+      "@systemfsoftware/source": "./src/index.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@stryker-mutator/api": "^9.6.1",
+    "@stryker-mutator/util": "^9.6.1",
+    "semver": "^7.7.0",
+    "tslib": "~2.8.0",
+    "typescript": "^7"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "@types/semver": "^7.5.8",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.22.7",
+    "vitest": "^4",
+    "@systemfsoftware/tsconfig": "^1.0.0",
+    "@systemfsoftware/vitest-config": "^0.1.0"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "oxlint ."
+  }
+}

package/schema/typescript-checker-options.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "TypescriptCheckerPluginOptions",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "typescriptChecker": {
+      "description": "Configuration for @systemfsoftware/stryker-js-typescript-checker",
+      "title": "TypescriptCheckerOptions",
+      "additionalProperties": false,
+      "type": "object",
+      "default": {},
+      "properties": {
+        "prioritizePerformanceOverAccuracy": {
+          "description": "Configures the performance of the TypescriptChecker. Setting this to false results in a slower, but more accurate result.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    }
+  }
+}