@flint.fyi/rule-tester 0.14.3 → 0.16.1

package/lib/RuleTester.d.ts

@@ -1,20 +1,42 @@
-import { AnyOptionalSchema, AnyRule, InferredObject, RuleAbout } from "@flint.fyi/core";
 import { InvalidTestCase, ValidTestCase } from "./types.js";
-export interface RuleTesterOptions {
-    describe?: TesterSetupDescribe;
-    it?: TesterSetupIt;
-    only?: TesterSetupIt;
-    scope?: Record<string, unknown>;
-    skip?: TesterSetupIt;
+import { AnyOptionalSchema, AnyRule, InferredInputObject, RuleAbout } from "@flint.fyi/core";
+
+//#region src/RuleTester.d.ts
+interface RuleTesterDefaults {
+  fileName?: string;
+  files?: Record<string, string>;
 }
-export interface TestCases<Options extends object | undefined> {
-    invalid: InvalidTestCase<Options>[];
-    valid: ValidTestCase<Options>[];
+interface RuleTesterOptions {
+  defaults?: RuleTesterDefaults;
+  describe?: TesterSetupDescribe;
+  diskBackedFSRoot?: string;
+  it?: TesterSetupIt;
+  only?: TesterSetupIt;
+  scope?: Record<string, unknown>;
+  skip?: TesterSetupIt;
 }
-export type TesterSetupDescribe = (description: string, setup: () => void) => void;
-export type TesterSetupIt = (description: string, setup: () => Promise<void>) => void;
-export declare class RuleTester {
-    #private;
-    constructor({ describe, it, only, scope, skip, }?: RuleTesterOptions);
-    describe<OptionsSchema extends AnyOptionalSchema | undefined>(rule: AnyRule<RuleAbout, OptionsSchema>, { invalid, valid }: TestCases<InferredObject<OptionsSchema>>): void;
+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,98 +1,99 @@
-import { CachedFactory } from "cached-factory";
-import assert from "node:assert";
+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";
-export class RuleTester {
-    #fileFactories;
-    #testerOptions;
-    constructor({ describe, it, only, scope = globalThis, skip, } = {}) {
-        this.#fileFactories = new CachedFactory((language) => language.prepare());
-        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 = {
-            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.#itTestCase(testCaseNormalized, async () => {
-            const reports = await runTestCaseRule(this.#fileFactories, {
-                // TODO: Figure out a way around the type assertion...
-                options: testCase.options ?? {},
-                rule,
-            }, testCaseNormalized);
-            const actualSnapshot = createReportSnapshot(testCase.code, reports);
-            assert.equal(actualSnapshot, testCase.snapshot);
-            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.code, setup);
-    }
-    #itValidCase(rule, testCaseRaw) {
-        const testCase = typeof testCaseRaw === "string" ? { code: testCaseRaw } : testCaseRaw;
-        const testCaseNormalized = normalizeTestCase(testCase);
-        this.#itTestCase(testCaseNormalized, async () => {
-            const reports = await runTestCaseRule(this.#fileFactories, {
-                // TODO: Figure out a way around the type assertion...
-                options: (testCase.options ?? {}),
-                rule,
-            }, testCaseNormalized);
-            if (reports.length) {
-                assert.deepStrictEqual(createReportSnapshot(testCaseNormalized.code, reports), testCaseNormalized.code);
-            }
-        });
-    }
-}
+import { createDiskBackedLinterHost, createEphemeralLinterHost, createVFSLinterHost, parseOptions } from "@flint.fyi/core";
+import { CachedFactory } from "cached-factory";
+import assert from "node:assert/strict";
+import path from "node:path";
+//#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`);
+	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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,10 @@
+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,2 +1,3 @@
-import { NormalizedReport } from "@flint.fyi/core";
+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,38 +1,78 @@
-import { formatReportPrimary } from "@flint.fyi/core";
-export function createReportSnapshot(sourceText, reports) {
-    let result = sourceText;
-    for (const report of reports.toReversed()) {
-        result = createReportSnapshotAt(result, report);
-    }
-    return result;
+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 } = report.range;
-    const lineStartIndex = sourceText.lastIndexOf("\n", begin.raw) + 1;
-    let lineEndIndex = sourceText.indexOf("\n", end.raw);
-    if (lineEndIndex < 0) {
-        lineEndIndex = sourceText.length;
-    }
-    const lines = sourceText.slice(lineStartIndex, lineEndIndex).split("\n");
-    const output = [];
-    for (let i = begin.line; i <= end.line; i++) {
-        const line = lines[i - begin.line];
-        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 formatReportPrimary(report).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));
+	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,2 +1,3 @@
-export { RuleTester } from "./RuleTester.js";
-export type * from "./types.js";
+import { InvalidTestCase, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject } from "./types.js";
+import { RuleTester } from "./RuleTester.js";
+export { InvalidTestCase, RuleTester, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject };

package/lib/index.js

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

package/lib/normalizeTestCase.d.ts

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

package/lib/normalizeTestCase.js

@@ -1,6 +1,10 @@
-export function normalizeTestCase(testCase) {
-    return {
-        fileName: "file.ts",
-        ...testCase,
-    };
+//#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,2 +1,3 @@
-import { TestSuggestion, TestSuggestionForFiles } from "./types.js";
+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,3 +1,8 @@
-export function isTestSuggestionForFiles(suggestion) {
-    return "files" in suggestion;
+//#region src/predicates.ts
+function isTestSuggestionForFiles(suggestion) {
+	return "files" in suggestion;
 }
+//#endregion
+export { isTestSuggestionForFiles };
+
+//# sourceMappingURL=predicates.js.map

package/lib/resolveReportedSuggestions.d.ts

@@ -1,14 +1,15 @@
-import { NormalizedReport } from "@flint.fyi/core";
-import { TestCaseNormalized } from "./normalizeTestCase.js";
-import { InvalidTestCase, TestSuggestionFileCase } from "./types.js";
+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?: undefined;
+    updated?: never;
 } | {
     id: string;
     updated: string;
-    files?: undefined;
+    files?: never;
 })[] | undefined;
+//# sourceMappingURL=resolveReportedSuggestions.d.ts.map

package/lib/resolveReportedSuggestions.js

@@ -1,46 +1,34 @@
-import { applyChangesToText, isSuggestionForFiles, } from "@flint.fyi/core";
-import { isTruthy } from "@flint.fyi/utils";
 import { isTestSuggestionForFiles } from "./predicates.js";
-export function resolveReportedSuggestions(reports, testCaseNormalized) {
-    const suggestionsReported = reports
-        .flatMap((report) => report.suggestions)
-        .filter(isTruthy);
-    if (!suggestionsReported.length) {
-        return undefined;
-    }
-    return suggestionsReported.map((suggestionReported) => isSuggestionForFiles(suggestionReported)
-        ? {
-            files: resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized),
-            id: suggestionReported.id,
-        }
-        : {
-            id: suggestionReported.id,
-            updated: applyChangesToText([suggestionReported], testCaseNormalized.code),
-        });
+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
-        .map((suggestionExpected) => {
-        return Object.entries(suggestionExpected.files).map(([filePath, suggestionCasesExpected]) => {
-            return [
-                filePath,
-                suggestionCasesExpected.map((suggestionCaseExpected) => {
-                    const changes = suggestionReported.files[filePath]?.(suggestionCaseExpected.original);
-                    return {
-                        original: suggestionCaseExpected.original,
-                        updated: changes
-                            ? applyChangesToText(changes, suggestionCaseExpected.original)
-                            : suggestionCaseExpected.original,
-                    };
-                }),
-            ];
-        });
-    })
-        .flat());
+	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,8 +1,9 @@
-import { AnyLanguage, AnyOptionalSchema, AnyRule, InferredObject, LanguageFileFactory, RuleAbout } from "@flint.fyi/core";
-import { CachedFactory } from "cached-factory";
-import { TestCaseNormalized } from "./normalizeTestCase.js";
+import { type AnyLanguage, type AnyLanguageFileFactory, type AnyOptionalSchema, type AnyRule, type InferredOutputObject, type NormalizedReport, type RuleAbout, type VFSLinterHost } from "@flint.fyi/core";
+import type { CachedFactory } from "cached-factory";
+import type { TestCaseNormalized } from "./normalizeTestCase.ts";
 export interface TestCaseRuleConfiguration<OptionsSchema extends AnyOptionalSchema | undefined> {
-    options?: InferredObject<OptionsSchema>;
+    options?: InferredOutputObject<OptionsSchema | undefined>;
     rule: AnyRule<RuleAbout, OptionsSchema>;
 }
-export declare function runTestCaseRule<OptionsSchema extends AnyOptionalSchema | undefined>(fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>, { options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>, { code, fileName }: TestCaseNormalized): import("@flint.fyi/core/lib/types/promises.js").PromiseOrSync<import("@flint.fyi/core").NormalizedReport[]>;
+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,9 +1,40 @@
-export function runTestCaseRule(fileFactories, { options, rule }, { code, fileName }) {
-    using file = fileFactories
-        // TODO: How to make types more permissive around assignability?
-        // See AnyRule's any
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        .get(rule.language)
-        .prepareFromVirtual(fileName, code).file;
-    return file.runRule(rule, options);
+import { processRuleReport } from "@flint.fyi/core";
+import assert from "node:assert/strict";
+import path from "node:path";
+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;
 }
+//#endregion
+export { runTestCaseRule };
+
+//# sourceMappingURL=runTestCaseRule.js.map