@flint.fyi/rule-tester 0.16.4 → 0.17.0

package/dist/index.d.mts

@@ -0,0 +1,81 @@
+import { AnyOptionalSchema, AnyRule, InferredInputObject, RuleAbout } from "@flint.fyi/core";
+
+//#region src/types.d.ts
+interface InvalidTestCase<Options extends object | undefined = object | undefined> extends TestCase<Options> {
+  output?: string;
+  snapshot: string;
+  suggestions?: TestSuggestion[];
+}
+interface TestCase<Options extends object | undefined = object | undefined> {
+  code: string;
+  fileName?: string | undefined;
+  files?: Record<string, string> | undefined;
+  name?: string | undefined;
+  /**
+   * Run only this test case. Useful for debugging.
+   *
+   * Do not commit code with this flag set.
+   */
+  only?: boolean;
+  options?: Options | undefined;
+  /**
+   * Skip running this test case. Useful for work-in-progress tests.
+   *
+   * Do not commit code with this flag set.
+   */
+  skip?: boolean;
+}
+type TestSuggestion = TestSuggestionForFile | TestSuggestionForFiles;
+interface TestSuggestionFileCase {
+  original: string;
+  updated: string;
+}
+interface TestSuggestionForFile {
+  id: string;
+  updated: string;
+}
+interface TestSuggestionForFiles {
+  files: Record<string, TestSuggestionFileCase[]>;
+  id: string;
+}
+type ValidTestCase<Options extends object | undefined> = string | ValidTestCaseObject<Options>;
+type ValidTestCaseObject<Options extends object | undefined> = TestCase<Options>;
+//#endregion
+//#region src/RuleTester.d.ts
+interface RuleTesterDefaults {
+  fileName?: string;
+  files?: Record<string, string>;
+}
+interface RuleTesterOptions {
+  defaults?: RuleTesterDefaults;
+  describe?: TesterSetupDescribe;
+  diskBackedFSRoot?: string;
+  it?: TesterSetupIt;
+  only?: TesterSetupIt;
+  scope?: Record<string, unknown>;
+  skip?: TesterSetupIt;
+}
+interface TestCases<Options extends object | undefined> {
+  invalid: InvalidTestCase<Options>[];
+  valid: ValidTestCase<Options>[];
+}
+type TesterSetupDescribe = (description: string, setup: () => void) => void;
+type TesterSetupIt = (description: string, setup: () => Promise<void>) => void;
+declare class RuleTester {
+  #private;
+  constructor({
+    defaults,
+    describe,
+    diskBackedFSRoot,
+    it,
+    only,
+    scope,
+    skip
+  }?: RuleTesterOptions);
+  describe<OptionsSchema extends AnyOptionalSchema | undefined>(rule: AnyRule<RuleAbout, OptionsSchema>, {
+    invalid,
+    valid
+  }: TestCases<InferredInputObject<OptionsSchema>>): void;
+}
+//#endregion
+export { type InvalidTestCase, RuleTester, type TestCase, type TestSuggestion, type TestSuggestionFileCase, type TestSuggestionForFile, type TestSuggestionForFiles, type ValidTestCase, type ValidTestCaseObject };

package/dist/index.mjs

@@ -0,0 +1,245 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { CachedFactory } from "cached-factory";
+import { applyChangesToText, createDiskBackedLinterHost, createEphemeralLinterHost, createVFSLinterHost, formatReport, getPositionOfColumnAndLine, isSuggestionForFiles, parseOptions, processRuleReport } from "@flint.fyi/core";
+import { isTruthy, normalizePath, nullThrows, pathKey } from "@flint.fyi/utils";
+//#region src/createOutput.ts
+function createOutput(reports, testCaseNormalized) {
+	const changes = reports.filter((report) => report.fix !== void 0).flatMap((report) => report.fix);
+	return changes.length ? applyChangesToText(changes, testCaseNormalized.code) : void 0;
+}
+//#endregion
+//#region src/createReportSnapshot.ts
+function createReportSnapshot(sourceText, reports) {
+	let result = sourceText;
+	for (const report of reports.toReversed()) result = createReportSnapshotAt(result, report);
+	return result;
+}
+function createReportSnapshotAt(sourceText, report) {
+	const { begin, end } = getDisplayedRange(sourceText, report.range);
+	const lineStartIndex = begin.raw - begin.column;
+	const lineEndIndex = getLineBounds(sourceText, end.line).end;
+	const lines = sourceText.slice(lineStartIndex, lineEndIndex).split("\n");
+	const output = [];
+	for (let i = begin.line; i <= end.line; i++) {
+		const line = nullThrows(lines[i - begin.line], "Line is expected to be present by the loop condition");
+		output.push(line);
+		const prevLineIndent = /^[\t ]*/.exec(line)?.[0] ?? "";
+		if (i === begin.line) {
+			const indent = prevLineIndent.padEnd(begin.column, " ");
+			const squiggleEnd = begin.line === end.line ? end.column : line.length;
+			output.push(indent.padEnd(squiggleEnd, "~"));
+			for (const errorMessageLine of formatReport(report.data, report.message.primary).split("\n")) output.push(indent + errorMessageLine);
+		} else {
+			const squiggleEnd = i === end.line ? end.column : line.length;
+			output.push(prevLineIndent.padEnd(squiggleEnd, "~"));
+		}
+	}
+	return sourceText.slice(0, lineStartIndex) + output.join("\n") + sourceText.slice(lineEndIndex);
+}
+function getDisplayedRange(sourceText, { begin, end }) {
+	if (end.column > 0 || end.line === begin.line) return {
+		begin,
+		end
+	};
+	const previousLine = getLineBounds(sourceText, end.line - 1);
+	if (begin.line === previousLine.line && previousLine.text === "") {
+		const currentLine = getLineBounds(sourceText, end.line);
+		if (currentLine.text !== "") return {
+			begin: {
+				column: 0,
+				line: currentLine.line,
+				raw: currentLine.start
+			},
+			end: {
+				column: 1,
+				line: currentLine.line,
+				raw: currentLine.start + 1
+			}
+		};
+	}
+	return {
+		begin,
+		end: {
+			column: previousLine.text.length,
+			line: previousLine.line,
+			raw: previousLine.end
+		}
+	};
+}
+function getLineBounds(sourceText, line) {
+	const start = getPositionOfColumnAndLine(sourceText, {
+		column: 0,
+		line
+	});
+	let end = sourceText.indexOf("\n", start);
+	if (end < 0) end = sourceText.length;
+	return {
+		end,
+		line,
+		start,
+		text: sourceText.slice(start, end)
+	};
+}
+//#endregion
+//#region src/normalizeTestCase.ts
+function normalizeTestCase(testCase, fileName) {
+	const rv = { ...testCase };
+	rv.fileName ??= fileName ?? "file.ts";
+	return rv;
+}
+//#endregion
+//#region src/predicates.ts
+function isTestSuggestionForFiles(suggestion) {
+	return "files" in suggestion;
+}
+//#endregion
+//#region src/resolveReportedSuggestions.ts
+function resolveReportedSuggestions(reports, testCaseNormalized) {
+	const suggestionsReported = reports.flatMap((report) => report.suggestions).filter(isTruthy);
+	if (!suggestionsReported.length) return;
+	return suggestionsReported.map((suggestionReported) => isSuggestionForFiles(suggestionReported) ? {
+		files: resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized),
+		id: suggestionReported.id
+	} : {
+		id: suggestionReported.id,
+		updated: applyChangesToText([suggestionReported], testCaseNormalized.code)
+	});
+}
+function resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized) {
+	if (!testCaseNormalized.suggestions) return {};
+	if (!testCaseNormalized.suggestions.every(isTestSuggestionForFiles)) throw new Error("This test case describes suggestions across files, but the rule is only reporting changes to its own file.");
+	return Object.fromEntries(testCaseNormalized.suggestions.flatMap((suggestionExpected) => {
+		return Object.entries(suggestionExpected.files).map(([filePath, suggestionCasesExpected]) => {
+			return [filePath, suggestionCasesExpected.map((suggestionCaseExpected) => {
+				const changes = suggestionReported.files[filePath];
+				return {
+					original: suggestionCaseExpected.original,
+					updated: changes ? applyChangesToText(changes, suggestionCaseExpected.original) : suggestionCaseExpected.original
+				};
+			})];
+		});
+	}));
+}
+//#endregion
+//#region src/runTestCaseRule.ts
+async function runTestCaseRule(fileFactories, linterHost, { options, rule }, { code, fileName, files }) {
+	const filePathAbsolute = normalizePath(path.resolve(linterHost.getCurrentDirectory(), fileName));
+	const caseSensitive = linterHost.isCaseSensitiveFS();
+	const targetKey = pathKey(filePathAbsolute, caseSensitive);
+	for (const oldFile of linterHost.vfsListFiles().keys()) if (pathKey(oldFile, caseSensitive) !== targetKey) linterHost.vfsDeleteFile(oldFile);
+	for (const [name, content] of Object.entries(files ?? {})) {
+		const filePath = normalizePath(path.resolve(linterHost.getCurrentDirectory(), name));
+		assert.notEqual(filePath, filePathAbsolute, `Expected 'files' not to shadow '${fileName}'`);
+		linterHost.vfsUpsertFile(filePath, content);
+	}
+	linterHost.vfsUpsertFile(filePathAbsolute, code);
+	using file = fileFactories.get(rule.language).createFile({
+		filePath: fileName,
+		filePathAbsolute,
+		sourceText: code
+	});
+	const reports = [];
+	const ruleRuntime = await rule.setup({
+		host: linterHost,
+		report(ruleReport) {
+			const processedReport = processRuleReport(file, rule, ruleReport);
+			if (processedReport == null) return;
+			reports.push(processedReport);
+		}
+	});
+	if (ruleRuntime) {
+		rule.language.runFileVisitors(file, options, ruleRuntime);
+		await ruleRuntime.teardown?.();
+	}
+	return reports.toSorted((a, b) => a.range.begin.raw - b.range.begin.raw || a.range.end.raw - b.range.end.raw);
+}
+//#endregion
+//#region src/RuleTester.ts
+var RuleTester = class {
+	#fileFactories;
+	#linterHost;
+	#testerOptions;
+	constructor({ defaults = {}, describe, diskBackedFSRoot, it, only, scope = globalThis, skip } = {}) {
+		let baseHost = diskBackedFSRoot != null ? createEphemeralLinterHost(createDiskBackedLinterHost(path.resolve(process.cwd(), diskBackedFSRoot, "_flint-rule-tester-virtual"))) : void 0;
+		const { files: defaultFiles = {} } = defaults;
+		if (Object.keys(defaultFiles).length) {
+			const vfs = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
+			for (const [name, content] of Object.entries(defaultFiles)) {
+				const filePath = path.resolve(vfs.getCurrentDirectory(), name);
+				vfs.vfsUpsertFile(filePath, content);
+			}
+			baseHost = vfs;
+		}
+		this.#linterHost = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
+		this.#fileFactories = new CachedFactory((language) => language.createFileFactory(this.#linterHost));
+		it = defaultTo(it, scope, "it");
+		if (!skip && "skip" in it && typeof it.skip === "function") skip = it.skip;
+		if (!only && "only" in it && typeof it.only === "function") only = it.only;
+		if (!skip) throw new TypeError("RuleTester needs a `skip` function");
+		if (!only) throw new TypeError("RuleTester needs a `only` function");
+		this.#testerOptions = {
+			defaults,
+			describe: defaultTo(describe, scope, "describe"),
+			it,
+			only,
+			scope,
+			skip
+		};
+	}
+	describe(rule, { invalid, valid }) {
+		this.#testerOptions.describe(rule.about.id, () => {
+			this.#testerOptions.describe("invalid", () => {
+				for (const testCase of invalid) this.#itInvalidCase(rule, testCase);
+			});
+			this.#testerOptions.describe("valid", () => {
+				for (const testCase of valid) this.#itValidCase(rule, testCase);
+			});
+		});
+	}
+	#itInvalidCase(rule, testCase) {
+		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
+		this.#itTestCase(testCaseNormalized, async () => {
+			const reports = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
+				options: parseOptions(rule.options, testCase.options),
+				rule
+			}, testCaseNormalized);
+			const actualSnapshot = createReportSnapshot(testCase.code, reports);
+			assert.equal(actualSnapshot, testCase.snapshot);
+			const actualOutput = createOutput(reports, testCaseNormalized);
+			assert.equal(testCase.output, actualOutput, "Expected `output` property to equal:");
+			const actualSuggestions = resolveReportedSuggestions(reports, testCaseNormalized);
+			assert.deepStrictEqual(actualSuggestions, testCase.suggestions);
+		});
+	}
+	#itTestCase(testCase, setup) {
+		let test = testCase.only ? this.#testerOptions.only : this.#testerOptions.it;
+		if (testCase.skip) if ("skip" in test && typeof test.skip === "function") test = test.skip;
+		else test = this.#testerOptions.skip;
+		test(testCase.name ?? ("files" in testCase ? JSON.stringify({
+			[testCase.fileName]: testCase.code,
+			...testCase.files
+		}, null, 2) : testCase.code), () => {
+			if (testCase.files != null) assert.notEqual(Object.keys(testCase.files).length, 0, `'files' must have at least one file`);
+			return setup();
+		});
+	}
+	#itValidCase(rule, testCaseRaw) {
+		const testCase = typeof testCaseRaw === "string" ? { code: testCaseRaw } : testCaseRaw;
+		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
+		this.#itTestCase(testCaseNormalized, async () => {
+			const reports = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
+				options: parseOptions(rule.options, testCase.options),
+				rule
+			}, testCaseNormalized);
+			if (reports.length) assert.deepStrictEqual(createReportSnapshot(testCaseNormalized.code, reports), testCaseNormalized.code);
+		});
+	}
+};
+function defaultTo(provided, scope, scopeKey) {
+	if (provided) return provided;
+	if (scopeKey in scope && typeof scope[scopeKey] === "function") return scope[scopeKey];
+	throw new Error(`No ${scopeKey} function found`);
+}
+//#endregion
+export { RuleTester };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/rule-tester",
-  "version": "0.16.4",
+  "version": "0.17.0",
   "description": "[Experimental] Rule unit tests for Flint.",
   "homepage": "https://flint.fyi",
   "repository": {
@@ -16,20 +16,20 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": "./lib/index.js"
+    ".": "./dist/index.mjs"
   },
   "files": [
-    "lib/",
-    "!lib/**/*.map"
+    "dist/"
   ],
   "dependencies": {
-    "cached-factory": "^0.2.0",
-    "@flint.fyi/core": "^0.23.0",
-    "@flint.fyi/utils": "^0.14.1"
+    "cached-factory": "^0.3.0",
+    "@flint.fyi/core": "^0.24.0",
+    "@flint.fyi/utils": "^0.15.0"
   },
   "devDependencies": {
-    "tsdown": "0.21.0",
-    "vitest": "4.1.0"
+    "tsdown": "0.22.3",
+    "vitest": "4.1.0",
+    "@flint.fyi/build": "^0.1.0"
   },
   "engines": {
     "node": ">=24.0.0"

package/lib/RuleTester.d.ts

@@ -1,42 +0,0 @@
-import { InvalidTestCase, ValidTestCase } from "./types.js";
-import { AnyOptionalSchema, AnyRule, InferredInputObject, RuleAbout } from "@flint.fyi/core";
-
-//#region src/RuleTester.d.ts
-interface RuleTesterDefaults {
-  fileName?: string;
-  files?: Record<string, string>;
-}
-interface RuleTesterOptions {
-  defaults?: RuleTesterDefaults;
-  describe?: TesterSetupDescribe;
-  diskBackedFSRoot?: string;
-  it?: TesterSetupIt;
-  only?: TesterSetupIt;
-  scope?: Record<string, unknown>;
-  skip?: TesterSetupIt;
-}
-interface TestCases<Options extends object | undefined> {
-  invalid: InvalidTestCase<Options>[];
-  valid: ValidTestCase<Options>[];
-}
-type TesterSetupDescribe = (description: string, setup: () => void) => void;
-type TesterSetupIt = (description: string, setup: () => Promise<void>) => void;
-declare class RuleTester {
-  #private;
-  constructor({
-    defaults,
-    describe,
-    diskBackedFSRoot,
-    it,
-    only,
-    scope,
-    skip
-  }?: RuleTesterOptions);
-  describe<OptionsSchema extends AnyOptionalSchema | undefined>(rule: AnyRule<RuleAbout, OptionsSchema>, {
-    invalid,
-    valid
-  }: TestCases<InferredInputObject<OptionsSchema>>): void;
-}
-//#endregion
-export { RuleTester };
-//# sourceMappingURL=RuleTester.d.ts.map

package/lib/RuleTester.js

@@ -1,99 +0,0 @@
-import { createOutput } from "./createOutput.js";
-import { createReportSnapshot } from "./createReportSnapshot.js";
-import { normalizeTestCase } from "./normalizeTestCase.js";
-import { resolveReportedSuggestions } from "./resolveReportedSuggestions.js";
-import { runTestCaseRule } from "./runTestCaseRule.js";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { CachedFactory } from "cached-factory";
-import { createDiskBackedLinterHost, createEphemeralLinterHost, createVFSLinterHost, parseOptions } from "@flint.fyi/core";
-//#region src/RuleTester.ts
-var RuleTester = class {
-	#fileFactories;
-	#linterHost;
-	#testerOptions;
-	constructor({ defaults = {}, describe, diskBackedFSRoot, it, only, scope = globalThis, skip } = {}) {
-		let baseHost = diskBackedFSRoot != null ? createEphemeralLinterHost(createDiskBackedLinterHost(path.resolve(process.cwd(), diskBackedFSRoot, "_flint-rule-tester-virtual"))) : void 0;
-		const { files: defaultFiles = {} } = defaults;
-		if (Object.keys(defaultFiles).length) {
-			const vfs = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
-			for (const [name, content] of Object.entries(defaultFiles)) {
-				const filePath = path.resolve(vfs.getCurrentDirectory(), name);
-				vfs.vfsUpsertFile(filePath, content);
-			}
-			baseHost = vfs;
-		}
-		this.#linterHost = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
-		this.#fileFactories = new CachedFactory((language) => language.createFileFactory(this.#linterHost));
-		it = defaultTo(it, scope, "it");
-		if (!skip && "skip" in it && typeof it.skip === "function") skip = it.skip;
-		if (!only && "only" in it && typeof it.only === "function") only = it.only;
-		if (!skip) throw new TypeError("RuleTester needs a `skip` function");
-		if (!only) throw new TypeError("RuleTester needs a `only` function");
-		this.#testerOptions = {
-			defaults,
-			describe: defaultTo(describe, scope, "describe"),
-			it,
-			only,
-			scope,
-			skip
-		};
-	}
-	describe(rule, { invalid, valid }) {
-		this.#testerOptions.describe(rule.about.id, () => {
-			this.#testerOptions.describe("invalid", () => {
-				for (const testCase of invalid) this.#itInvalidCase(rule, testCase);
-			});
-			this.#testerOptions.describe("valid", () => {
-				for (const testCase of valid) this.#itValidCase(rule, testCase);
-			});
-		});
-	}
-	#itInvalidCase(rule, testCase) {
-		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
-		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
-				options: parseOptions(rule.options, testCase.options),
-				rule
-			}, testCaseNormalized);
-			const actualSnapshot = createReportSnapshot(testCase.code, reports);
-			assert.equal(actualSnapshot, testCase.snapshot);
-			const actualOutput = createOutput(reports, testCaseNormalized);
-			assert.equal(testCase.output, actualOutput, "Expected `output` property to equal:");
-			const actualSuggestions = resolveReportedSuggestions(reports, testCaseNormalized);
-			assert.deepStrictEqual(actualSuggestions, testCase.suggestions);
-		});
-	}
-	#itTestCase(testCase, setup) {
-		let test = testCase.only ? this.#testerOptions.only : this.#testerOptions.it;
-		if (testCase.skip) if ("skip" in test && typeof test.skip === "function") test = test.skip;
-		else test = this.#testerOptions.skip;
-		test(testCase.name ?? ("files" in testCase ? JSON.stringify({
-			[testCase.fileName]: testCase.code,
-			...testCase.files
-		}, null, 2) : testCase.code), () => {
-			if (testCase.files != null) assert.notEqual(Object.keys(testCase.files), 0, `'files' must have at least one file`);
-			return setup();
-		});
-	}
-	#itValidCase(rule, testCaseRaw) {
-		const testCase = typeof testCaseRaw === "string" ? { code: testCaseRaw } : testCaseRaw;
-		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
-		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
-				options: parseOptions(rule.options, testCase.options),
-				rule
-			}, testCaseNormalized);
-			if (reports.length) assert.deepStrictEqual(createReportSnapshot(testCaseNormalized.code, reports), testCaseNormalized.code);
-		});
-	}
-};
-function defaultTo(provided, scope, scopeKey) {
-	if (provided) return provided;
-	if (scopeKey in scope && typeof scope[scopeKey] === "function") return scope[scopeKey];
-	throw new Error(`No ${scopeKey} function found`);
-}
-//#endregion
-export { RuleTester };
-
-//# sourceMappingURL=RuleTester.js.map

package/lib/createOutput.d.ts

@@ -1,5 +0,0 @@
-import { type NormalizedReport } from "@flint.fyi/core";
-import type { TestCaseNormalized } from "./normalizeTestCase.ts";
-import type { InvalidTestCase } from "./types.ts";
-export declare function createOutput(reports: NormalizedReport[], testCaseNormalized: InvalidTestCase & TestCaseNormalized): string | undefined;
-//# sourceMappingURL=createOutput.d.ts.map

package/lib/createOutput.js

@@ -1,10 +0,0 @@
-import { applyChangesToText } from "@flint.fyi/core";
-//#region src/createOutput.ts
-function createOutput(reports, testCaseNormalized) {
-	const changes = reports.filter((report) => report.fix !== void 0).flatMap((report) => report.fix);
-	return changes.length ? applyChangesToText(changes, testCaseNormalized.code) : void 0;
-}
-//#endregion
-export { createOutput };
-
-//# sourceMappingURL=createOutput.js.map

package/lib/createReportSnapshot.d.ts

@@ -1,3 +0,0 @@
-import { type NormalizedReport } from "@flint.fyi/core";
-export declare function createReportSnapshot(sourceText: string, reports: NormalizedReport[]): string;
-//# sourceMappingURL=createReportSnapshot.d.ts.map

package/lib/createReportSnapshot.js

@@ -1,78 +0,0 @@
-import { formatReport, getPositionOfColumnAndLine } from "@flint.fyi/core";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/createReportSnapshot.ts
-function createReportSnapshot(sourceText, reports) {
-	let result = sourceText;
-	for (const report of reports.toReversed()) result = createReportSnapshotAt(result, report);
-	return result;
-}
-function createReportSnapshotAt(sourceText, report) {
-	const { begin, end } = getDisplayedRange(sourceText, report.range);
-	const lineStartIndex = begin.raw - begin.column;
-	const lineEndIndex = getLineBounds(sourceText, end.line).end;
-	const lines = sourceText.slice(lineStartIndex, lineEndIndex).split("\n");
-	const output = [];
-	for (let i = begin.line; i <= end.line; i++) {
-		const line = nullThrows(lines[i - begin.line], "Line is expected to be present by the loop condition");
-		output.push(line);
-		const prevLineIndent = /^[\t ]*/.exec(line)?.[0] ?? "";
-		if (i === begin.line) {
-			const indent = prevLineIndent.padEnd(begin.column, " ");
-			const squiggleEnd = begin.line === end.line ? end.column : line.length;
-			output.push(indent.padEnd(squiggleEnd, "~"));
-			for (const errorMessageLine of formatReport(report.data, report.message.primary).split("\n")) output.push(indent + errorMessageLine);
-		} else {
-			const squiggleEnd = i === end.line ? end.column : line.length;
-			output.push(prevLineIndent.padEnd(squiggleEnd, "~"));
-		}
-	}
-	return sourceText.slice(0, lineStartIndex) + output.join("\n") + sourceText.slice(lineEndIndex);
-}
-function getDisplayedRange(sourceText, { begin, end }) {
-	if (end.column > 0 || end.line === begin.line) return {
-		begin,
-		end
-	};
-	const previousLine = getLineBounds(sourceText, end.line - 1);
-	if (begin.line === previousLine.line && previousLine.text === "") {
-		const currentLine = getLineBounds(sourceText, end.line);
-		if (currentLine.text !== "") return {
-			begin: {
-				column: 0,
-				line: currentLine.line,
-				raw: currentLine.start
-			},
-			end: {
-				column: 1,
-				line: currentLine.line,
-				raw: currentLine.start + 1
-			}
-		};
-	}
-	return {
-		begin,
-		end: {
-			column: previousLine.text.length,
-			line: previousLine.line,
-			raw: previousLine.end
-		}
-	};
-}
-function getLineBounds(sourceText, line) {
-	const start = getPositionOfColumnAndLine(sourceText, {
-		column: 0,
-		line
-	});
-	let end = sourceText.indexOf("\n", start);
-	if (end < 0) end = sourceText.length;
-	return {
-		end,
-		line,
-		start,
-		text: sourceText.slice(start, end)
-	};
-}
-//#endregion
-export { createReportSnapshot };
-
-//# sourceMappingURL=createReportSnapshot.js.map

package/lib/index.d.ts

@@ -1,3 +0,0 @@
-import { InvalidTestCase, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject } from "./types.js";
-import { RuleTester } from "./RuleTester.js";
-export { type InvalidTestCase, RuleTester, type TestCase, type TestSuggestion, type TestSuggestionFileCase, type TestSuggestionForFile, type TestSuggestionForFiles, type ValidTestCase, type ValidTestCaseObject };

package/lib/index.js

@@ -1,2 +0,0 @@
-import { RuleTester } from "./RuleTester.js";
-export { RuleTester };

package/lib/normalizeTestCase.d.ts

@@ -1,6 +0,0 @@
-import type { TestCase } from "./types.ts";
-export interface TestCaseNormalized extends TestCase {
-    fileName: string;
-}
-export declare function normalizeTestCase<T extends TestCase>(testCase: T, fileName: string | undefined): T & TestCaseNormalized;
-//# sourceMappingURL=normalizeTestCase.d.ts.map

package/lib/normalizeTestCase.js

@@ -1,10 +0,0 @@
-//#region src/normalizeTestCase.ts
-function normalizeTestCase(testCase, fileName) {
-	const rv = { ...testCase };
-	rv.fileName ??= fileName ?? "file.ts";
-	return rv;
-}
-//#endregion
-export { normalizeTestCase };
-
-//# sourceMappingURL=normalizeTestCase.js.map

package/lib/predicates.d.ts

@@ -1,3 +0,0 @@
-import type { TestSuggestion, TestSuggestionForFiles } from "./types.ts";
-export declare function isTestSuggestionForFiles(suggestion: TestSuggestion): suggestion is TestSuggestionForFiles;
-//# sourceMappingURL=predicates.d.ts.map

package/lib/predicates.js

@@ -1,8 +0,0 @@
-//#region src/predicates.ts
-function isTestSuggestionForFiles(suggestion) {
-	return "files" in suggestion;
-}
-//#endregion
-export { isTestSuggestionForFiles };
-
-//# sourceMappingURL=predicates.js.map

package/lib/resolveReportedSuggestions.d.ts

@@ -1,15 +0,0 @@
-import { type NormalizedReport } from "@flint.fyi/core";
-import type { TestCaseNormalized } from "./normalizeTestCase.ts";
-import type { InvalidTestCase, TestSuggestionFileCase } from "./types.ts";
-export declare function resolveReportedSuggestions(reports: NormalizedReport[], testCaseNormalized: InvalidTestCase & TestCaseNormalized): ({
-    files: {
-        [k: string]: TestSuggestionFileCase[];
-    };
-    id: string;
-    updated?: never;
-} | {
-    id: string;
-    updated: string;
-    files?: never;
-})[] | undefined;
-//# sourceMappingURL=resolveReportedSuggestions.d.ts.map

package/lib/resolveReportedSuggestions.js

@@ -1,34 +0,0 @@
-import { isTestSuggestionForFiles } from "./predicates.js";
-import { applyChangesToText, isSuggestionForFiles } from "@flint.fyi/core";
-import { isTruthy } from "@flint.fyi/utils";
-//#region src/resolveReportedSuggestions.ts
-function resolveReportedSuggestions(reports, testCaseNormalized) {
-	const suggestionsReported = reports.flatMap((report) => report.suggestions).filter(isTruthy);
-	if (!suggestionsReported.length) return;
-	return suggestionsReported.map((suggestionReported) => isSuggestionForFiles(suggestionReported) ? {
-		files: resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized),
-		id: suggestionReported.id
-	} : {
-		id: suggestionReported.id,
-		updated: applyChangesToText([suggestionReported], testCaseNormalized.code)
-	});
-}
-function resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized) {
-	if (!testCaseNormalized.suggestions) return {};
-	if (!testCaseNormalized.suggestions.every(isTestSuggestionForFiles)) throw new Error("This test case describes suggestions across files, but the rule is only reporting changes to its own file.");
-	return Object.fromEntries(testCaseNormalized.suggestions.flatMap((suggestionExpected) => {
-		return Object.entries(suggestionExpected.files).map(([filePath, suggestionCasesExpected]) => {
-			return [filePath, suggestionCasesExpected.map((suggestionCaseExpected) => {
-				const changes = suggestionReported.files[filePath];
-				return {
-					original: suggestionCaseExpected.original,
-					updated: changes ? applyChangesToText(changes, suggestionCaseExpected.original) : suggestionCaseExpected.original
-				};
-			})];
-		});
-	}));
-}
-//#endregion
-export { resolveReportedSuggestions };
-
-//# sourceMappingURL=resolveReportedSuggestions.js.map

package/lib/runTestCaseRule.d.ts

@@ -1,9 +0,0 @@
-import type { CachedFactory } from "cached-factory";
-import { type AnyLanguage, type AnyLanguageFileFactory, type AnyOptionalSchema, type AnyRule, type InferredOutputObject, type NormalizedReport, type RuleAbout, type VFSLinterHost } from "@flint.fyi/core";
-import type { TestCaseNormalized } from "./normalizeTestCase.ts";
-export interface TestCaseRuleConfiguration<OptionsSchema extends AnyOptionalSchema | undefined> {
-    options?: InferredOutputObject<OptionsSchema | undefined>;
-    rule: AnyRule<RuleAbout, OptionsSchema>;
-}
-export declare function runTestCaseRule<OptionsSchema extends AnyOptionalSchema | undefined>(fileFactories: CachedFactory<AnyLanguage, AnyLanguageFileFactory>, linterHost: VFSLinterHost, { options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>, { code, fileName, files }: TestCaseNormalized): Promise<NormalizedReport[]>;
-//# sourceMappingURL=runTestCaseRule.d.ts.map

package/lib/runTestCaseRule.js

@@ -1,40 +0,0 @@
-import assert from "node:assert/strict";
-import path from "node:path";
-import { processRuleReport } from "@flint.fyi/core";
-import { normalizePath, pathKey } from "@flint.fyi/utils";
-//#region src/runTestCaseRule.ts
-async function runTestCaseRule(fileFactories, linterHost, { options, rule }, { code, fileName, files }) {
-	const filePathAbsolute = normalizePath(path.resolve(linterHost.getCurrentDirectory(), fileName));
-	const caseSensitive = linterHost.isCaseSensitiveFS();
-	const targetKey = pathKey(filePathAbsolute, caseSensitive);
-	for (const oldFile of linterHost.vfsListFiles().keys()) if (pathKey(oldFile, caseSensitive) !== targetKey) linterHost.vfsDeleteFile(oldFile);
-	for (const [name, content] of Object.entries(files ?? {})) {
-		const filePath = normalizePath(path.resolve(linterHost.getCurrentDirectory(), name));
-		assert.notEqual(filePath, filePathAbsolute, `Expected 'files' not to shadow '${fileName}'`);
-		linterHost.vfsUpsertFile(filePath, content);
-	}
-	linterHost.vfsUpsertFile(filePathAbsolute, code);
-	using file = fileFactories.get(rule.language).createFile({
-		filePath: fileName,
-		filePathAbsolute,
-		sourceText: code
-	});
-	const reports = [];
-	const ruleRuntime = await rule.setup({
-		host: linterHost,
-		report(ruleReport) {
-			const processedReport = processRuleReport(file, rule, ruleReport);
-			if (processedReport == null) return;
-			reports.push(processedReport);
-		}
-	});
-	if (ruleRuntime) {
-		rule.language.runFileVisitors(file, options, ruleRuntime);
-		await ruleRuntime.teardown?.();
-	}
-	return reports.toSorted((a, b) => a.range.begin.raw - b.range.begin.raw || a.range.end.raw - b.range.end.raw);
-}
-//#endregion
-export { runTestCaseRule };
-
-//# sourceMappingURL=runTestCaseRule.js.map

package/lib/types.d.ts

@@ -1,43 +0,0 @@
-//#region src/types.d.ts
-interface InvalidTestCase<Options extends object | undefined = object | undefined> extends TestCase<Options> {
-  output?: string;
-  snapshot: string;
-  suggestions?: TestSuggestion[];
-}
-interface TestCase<Options extends object | undefined = object | undefined> {
-  code: string;
-  fileName?: string | undefined;
-  files?: Record<string, string> | undefined;
-  name?: string | undefined;
-  /**
-   * Run only this test case. Useful for debugging.
-   *
-   * Do not commit code with this flag set.
-   */
-  only?: boolean;
-  options?: Options | undefined;
-  /**
-   * Skip running this test case. Useful for work-in-progress tests.
-   *
-   * Do not commit code with this flag set.
-   */
-  skip?: boolean;
-}
-type TestSuggestion = TestSuggestionForFile | TestSuggestionForFiles;
-interface TestSuggestionFileCase {
-  original: string;
-  updated: string;
-}
-interface TestSuggestionForFile {
-  id: string;
-  updated: string;
-}
-interface TestSuggestionForFiles {
-  files: Record<string, TestSuggestionFileCase[]>;
-  id: string;
-}
-type ValidTestCase<Options extends object | undefined> = string | ValidTestCaseObject<Options>;
-type ValidTestCaseObject<Options extends object | undefined> = TestCase<Options>;
-//#endregion
-export { InvalidTestCase, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject };
-//# sourceMappingURL=types.d.ts.map