@flint.fyi/plugin-flint 0.2.1 → 0.5.0

package/lib/index.js

@@ -1,2 +1,837 @@
-export * from "./flint.js";
+import { RuleCreator, createPlugin } from "@flint.fyi/core";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import { isTruthy } from "@flint.fyi/utils";
+//#region src/utils/isTypeFromTS.ts
+function isTypeFromTS(node, typeChecker, typeName) {
+	const type = typeChecker.getTypeAtLocation(node);
+	const visited = /* @__PURE__ */ new Set();
+	function check(type) {
+		if (visited.has(type)) return false;
+		visited.add(type);
+		if (type.isUnionOrIntersection()) return type.types.some((subType) => check(subType));
+		const symbol = type.getSymbol();
+		if (symbol?.getName() === typeName) return symbol.getDeclarations()?.some((declaration) => {
+			const sourceFile = declaration.getSourceFile().fileName;
+			return sourceFile.includes("node_modules/typescript") && sourceFile.endsWith(".d.ts");
+		}) ?? false;
+		const bases = type.getBaseTypes();
+		if (bases?.length) return bases.some((baseType) => check(baseType));
+		return false;
+	}
+	return check(type);
+}
+//#endregion
+//#region src/rules/ruleCreator.ts
+const ruleCreator = new RuleCreator({
+	docs: (ruleId) => `https://flint.fyi/rules/flint/${ruleId.toLowerCase()}`,
+	pluginId: "flint",
+	presets: [
+		"logical",
+		"logicalStrict",
+		"stylistic",
+		"stylisticStrict"
+	]
+});
+//#endregion
+//#region src/rules/getStartSourceFile.ts
+var getStartSourceFile_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Requires passing `sourceFile` to `getStart()` for better performance.",
+		id: "getStartSourceFile",
+		presets: ["logical"]
+	},
+	messages: { missingSourceFile: {
+		primary: "`getStart()` should be called with a `sourceFile` parameter for better performance.",
+		secondary: [
+			"TypeScript allows calling `node.getStart()` with or without a source file.",
+			"Providing the source file is slightly faster because TypeScript doesn't need to traverse up the AST to find it.",
+			"Consider using `getTSNodeRange()` helper function which already handles this correctly."
+		],
+		suggestions: ["Pass `sourceFile` as the argument to `getStart()`: `node.getStart(sourceFile)`.", "Or use `getTSNodeRange(node, sourceFile)` helper function instead."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || node.expression.name.text !== "getStart" || !isTypeFromTS(node.expression.expression, typeChecker, "Node")) return;
+			if (!node.arguments.length) context.report({
+				message: "missingSourceFile",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/utils/findProperty.ts
+function findProperty(properties, name, predicate) {
+	return properties.find((property) => property.kind === SyntaxKind.PropertyAssignment && property.name.kind === SyntaxKind.Identifier && property.name.text === name && predicate(property.initializer))?.initializer;
+}
+//#endregion
+//#region src/utils/getRuleTesterCaseArrays.ts
+function getRuleTesterCaseArrays(node) {
+	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.expression.kind !== SyntaxKind.Identifier || node.expression.name.kind !== SyntaxKind.Identifier || node.expression.name.text !== "describe" || node.arguments.length !== 2) return;
+	const argument = node.arguments[1];
+	if (argument?.kind !== SyntaxKind.ObjectLiteralExpression) return;
+	const valid = findProperty(argument.properties, "valid", (node) => node.kind === SyntaxKind.ArrayLiteralExpression);
+	const invalid = findProperty(argument.properties, "invalid", (node) => node.kind === SyntaxKind.ArrayLiteralExpression);
+	if (!valid || !invalid) return;
+	return {
+		invalid,
+		valid
+	};
+}
+//#endregion
+//#region src/utils/tsAstToLiteral.ts
+function tsAstToLiteral(node) {
+	switch (node.kind) {
+		case SyntaxKind.FalseKeyword: return false;
+		case SyntaxKind.NullKeyword: return null;
+		case SyntaxKind.TrueKeyword: return true;
+	}
+	if (ts.isArrayLiteralExpression(node)) return node.elements.filter((element) => element.kind !== SyntaxKind.SpreadElement).map((element) => tsAstToLiteral(element));
+	if (ts.isNumericLiteral(node)) return parseFloat(node.text);
+	if (ts.isObjectLiteralExpression(node)) return Object.fromEntries(node.properties.filter((property) => ts.isPropertyAssignment(property) && (property.name.kind === SyntaxKind.Identifier || property.name.kind === SyntaxKind.StringLiteral)).map((property) => [property.name.escapedText || property.name.text, tsAstToLiteral(property.initializer)]));
+	if (ts.isStringLiteral(node)) return node.text;
+}
+//#endregion
+//#region src/utils/parseTestCases.ts
+function parseTestCase(node) {
+	if (node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return {
+		code: node.text,
+		nodes: {
+			case: node,
+			code: node
+		}
+	};
+	if (node.kind !== SyntaxKind.ObjectLiteralExpression) return;
+	const code = findProperty(node.properties, "code", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	if (!code) return;
+	const fileName = findProperty(node.properties, "fileName", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	const files = findProperty(node.properties, "files", (node) => node.kind === SyntaxKind.ObjectLiteralExpression);
+	const name = findProperty(node.properties, "name", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	const options = findProperty(node.properties, "options", (node) => node.kind === SyntaxKind.ObjectLiteralExpression);
+	return {
+		code: code.text,
+		fileName: fileName?.text,
+		files: files && tsAstToLiteral(files),
+		name: name?.text,
+		nodes: {
+			case: node,
+			code,
+			fileName,
+			files,
+			name,
+			options
+		},
+		options: options && tsAstToLiteral(options)
+	};
+}
+function parseTestCaseInvalid(node) {
+	if (node.kind !== SyntaxKind.ObjectLiteralExpression) return;
+	const code = findProperty(node.properties, "code", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	if (!code) return;
+	const fileName = findProperty(node.properties, "fileName", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	const files = findProperty(node.properties, "files", (node) => node.kind === SyntaxKind.ObjectLiteralExpression);
+	const name = findProperty(node.properties, "name", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	const options = findProperty(node.properties, "options", (node) => node.kind === SyntaxKind.ObjectLiteralExpression);
+	const snapshot = findProperty(node.properties, "snapshot", (node) => node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
+	if (!snapshot) return;
+	return {
+		code: code.text,
+		fileName: fileName?.text,
+		files: files && tsAstToLiteral(files),
+		name: name?.text,
+		nodes: {
+			case: node,
+			code,
+			fileName,
+			files,
+			name,
+			options,
+			snapshot
+		},
+		options: options && tsAstToLiteral(options),
+		snapshot: snapshot.text
+	};
+}
+//#endregion
+//#region src/utils/getRuleTesterDescribedCases.ts
+function getRuleTesterDescribedCases(node) {
+	const arrays = getRuleTesterCaseArrays(node);
+	if (!arrays) return;
+	return {
+		invalid: arrays.invalid.elements.map(parseTestCaseInvalid).filter(isTruthy),
+		valid: arrays.valid.elements.map(parseTestCase).filter(isTruthy)
+	};
+}
+//#endregion
+//#region src/rules/invalidCodeLines.ts
+var invalidCodeLines_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports cases for invalid code that isn't formatted across lines.",
+		id: "invalidCodeLines",
+		presets: ["logical"]
+	},
+	messages: { singleLineTest: {
+		primary: "This code block should be formatted across multiple lines for more readable reports.",
+		secondary: ["When writing `invalid` case code blocks, it's better to start code on a new line in a template literal string.", "Doing so allows the case's `snapshot` to visualize the `~` characters visually underneath reported ranges."],
+		suggestions: ["Delete this redundant test case.", "Change a property to make the test case unique."]
+	} },
+	setup(context) {
+		function checkTestCase(testCase, sourceFile) {
+			const fix = [...createNewlineFixes(testCase.code, testCase.nodes.code, sourceFile), ...createNewlineFixes(testCase.snapshot, testCase.nodes.snapshot, sourceFile)];
+			if (fix.length) context.report({
+				fix,
+				message: "singleLineTest",
+				range: getTSNodeRange(testCase.nodes.code, sourceFile)
+			});
+		}
+		function createNewlineFixes(code, node, sourceFile) {
+			if (node.kind === ts.SyntaxKind.StringLiteral) return [{
+				range: getTSNodeRange(node, sourceFile),
+				text: `\`\n${code}\n\``
+			}];
+			const changes = [];
+			if (!code.startsWith("\n")) changes.push({
+				range: {
+					begin: node.getStart(sourceFile) + 1,
+					end: node.getStart(sourceFile) + 1
+				},
+				text: "\n"
+			});
+			if (!code.endsWith("\n")) changes.push({
+				range: {
+					begin: node.getEnd() - 1,
+					end: node.getEnd() - 1
+				},
+				text: "\n"
+			});
+			return changes;
+		}
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const describedCases = getRuleTesterDescribedCases(node);
+			if (!describedCases) return;
+			for (const testCase of describedCases.invalid) checkTestCase(testCase, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/utils/messageHelpers.ts
+function findMessagesProperty(node) {
+	const args = node.arguments[1];
+	if (args?.kind !== SyntaxKind.ObjectLiteralExpression) return;
+	const messagesProperty = args.properties.find((prop) => {
+		return prop.kind === SyntaxKind.PropertyAssignment && prop.name.kind === SyntaxKind.Identifier && prop.name.text === "messages";
+	});
+	if (messagesProperty?.kind === SyntaxKind.PropertyAssignment) return messagesProperty;
+}
+function* forEachMessageString(messagesProperty) {
+	if (messagesProperty.initializer.kind !== SyntaxKind.ObjectLiteralExpression) return;
+	for (const prop of messagesProperty.initializer.properties) {
+		if (prop.kind !== SyntaxKind.PropertyAssignment || prop.name.kind !== SyntaxKind.Identifier || prop.initializer.kind !== SyntaxKind.ObjectLiteralExpression) continue;
+		const messageId = prop.name.text;
+		for (const messageProp of prop.initializer.properties) {
+			if (messageProp.kind !== SyntaxKind.PropertyAssignment || messageProp.name.kind !== SyntaxKind.Identifier) continue;
+			const propertyName = messageProp.name.text;
+			if (messageProp.initializer.kind === SyntaxKind.StringLiteral) yield {
+				isInArray: false,
+				messageId,
+				node: messageProp.initializer,
+				propertyName
+			};
+			if (messageProp.initializer.kind === SyntaxKind.ArrayLiteralExpression) {
+				for (const el of messageProp.initializer.elements) if (el.kind === SyntaxKind.StringLiteral) yield {
+					isInArray: true,
+					messageId,
+					node: el,
+					propertyName
+				};
+			}
+		}
+	}
+}
+function getStringOriginalQuote(node, sourceFile) {
+	return node.getText(sourceFile)[0] ?? "\"";
+}
+//#endregion
+//#region src/utils/ruleCreatorHelpers.ts
+function isLanguageCreateRule(node, typeChecker) {
+	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.text === "createRule" && !isRuleCreatorCreateRule(node, typeChecker);
+}
+function isTypedMethodCall(node, typeChecker, leftType, rightCall) {
+	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) return false;
+	const propertyAccess = node.expression;
+	return typeChecker.getTypeAtLocation(propertyAccess.expression).getSymbol()?.getName() === leftType && propertyAccess.name.text === rightCall;
+}
+const isRuleCreatorCreateRule = (node, typeChecker) => isTypedMethodCall(node, typeChecker, "RuleCreator", "createRule");
+const isRuleContextReport = (node, typeChecker) => isTypedMethodCall(node, typeChecker, "RuleContext", "report");
+//#endregion
+//#region src/rules/missingPlaceholders.ts
+function extractPlaceholders(text) {
+	const placeholders = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(/\{\{\s*(\w+)\s*\}\}/g)) if (match[1]) placeholders.add(match[1]);
+	return placeholders;
+}
+var missingPlaceholders_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports `context.report()` calls missing data for message placeholders.",
+		id: "missingPlaceholders",
+		presets: ["logical"]
+	},
+	messages: { missingPlaceholders: {
+		primary: "Message template requires placeholders in the data object.",
+		secondary: ["Message templates use `{{ placeholder }}` that must be provided via the data property.", "Each placeholder in the message template requires a corresponding key in the data object."],
+		suggestions: ["Add a data object with the required placeholder keys."]
+	} },
+	setup(context) {
+		const messagePlaceholders = /* @__PURE__ */ new Map();
+		function checkMessageInCreateRule(ruleCreatorNode) {
+			const messagesProperty = findMessagesProperty(ruleCreatorNode);
+			if (!messagesProperty) return;
+			for (const ctx of forEachMessageString(messagesProperty)) {
+				const placeholders = extractPlaceholders(ctx.node.text);
+				if (placeholders.size) {
+					const existing = messagePlaceholders.get(ctx.messageId);
+					if (existing) for (const p of placeholders) existing.add(p);
+					else messagePlaceholders.set(ctx.messageId, placeholders);
+				}
+			}
+		}
+		function populateMessageInCreateRule(contextNode, sourceFile) {
+			const args = contextNode.arguments[0];
+			if (args?.kind !== SyntaxKind.ObjectLiteralExpression) return;
+			const properties = args.properties;
+			const messageProperty = findProperty(properties, "message", (node) => node.kind === SyntaxKind.StringLiteral);
+			if (!messageProperty) return;
+			const requiredPlaceholders = messagePlaceholders.get(messageProperty.text);
+			if (!requiredPlaceholders?.size) return;
+			const dataProperty = properties.find((prop) => prop.kind === SyntaxKind.PropertyAssignment && prop.name.kind === SyntaxKind.Identifier && prop.name.text === "data");
+			if (!dataProperty) {
+				context.report({
+					data: { placeholder: Array.from(requiredPlaceholders).join(", ") },
+					message: "missingPlaceholders",
+					range: getTSNodeRange(messageProperty, sourceFile)
+				});
+				return;
+			}
+			if (dataProperty.initializer.kind !== SyntaxKind.ObjectLiteralExpression) return;
+			const dataKeys = /* @__PURE__ */ new Set();
+			dataProperty.initializer.properties.forEach((prop) => {
+				if (prop.kind === SyntaxKind.PropertyAssignment && prop.name.kind === SyntaxKind.Identifier) dataKeys.add(prop.name.text);
+				else if (prop.kind === SyntaxKind.ShorthandPropertyAssignment) dataKeys.add(prop.name.text);
+			});
+			const missingPlaceholders = /* @__PURE__ */ new Set();
+			for (const placeholder of requiredPlaceholders) if (!dataKeys.has(placeholder)) missingPlaceholders.add(placeholder);
+			if (missingPlaceholders.size) context.report({
+				data: { placeholder: Array.from(missingPlaceholders).join(", ") },
+				message: "missingPlaceholders",
+				range: getTSNodeRange(messageProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			CallExpression(node, { sourceFile, typeChecker }) {
+				if (isRuleCreatorCreateRule(node, typeChecker)) {
+					checkMessageInCreateRule(node);
+					return;
+				}
+				if (isRuleContextReport(node, typeChecker)) {
+					populateMessageInCreateRule(node, sourceFile);
+					return;
+				}
+			},
+			"SourceFile:exit"() {
+				messagePlaceholders.clear();
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/nodePropertyInChecks.ts
+var nodePropertyInChecks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallows using the `in` operator to check properties on TypeScript nodes.",
+		id: "nodePropertyInChecks",
+		presets: ["logical"]
+	},
+	messages: { nodePropertyInChecks: {
+		primary: "Avoid using the `in` operator to check properties on TypeScript nodes.",
+		secondary: ["The `in` operator checks inherited properties and may not work reliably with TypeScript AST nodes.", "TypeScript AST nodes have complex prototype chains that can lead to unexpected results with `in` checks."],
+		suggestions: ["Access the property directly or use a type guard function like `ts.isXXX()` instead."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression(node, { sourceFile, typeChecker }) {
+			if (node.operatorToken.kind === SyntaxKind.InKeyword && isTypeFromTS(node.right, typeChecker, "Node")) context.report({
+				message: "nodePropertyInChecks",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/placeholderFormats.ts
+function formatPlaceholders(text) {
+	return text.replaceAll(/\{\{\s*(\w+)\s*\}\}/g, "{{ $1 }}");
+}
+function hasMalformedPlaceholders(text) {
+	const matches = text.match(/\{\{\s*\w+\s*\}\}/g);
+	if (!matches) return false;
+	return matches.some((match) => !/\{\{ \w+ \}\}/.test(match));
+}
+var placeholderFormats_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports and auto-fixes message placeholders that are not formatted as `{{ placeholder }}`.",
+		id: "placeholderFormats",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { placeholderFormats: {
+		primary: "Placeholders should be formatted with single spaces inside the braces.",
+		secondary: ["Consistent formatting improves readability of message templates.", "Use exactly one space after the opening braces and before the closing braces."],
+		suggestions: ["Format placeholder with proper spacing."]
+	} },
+	setup(context) {
+		function checkStringLiteral(node, sourceFile) {
+			const text = node.text;
+			if (!hasMalformedPlaceholders(text)) return;
+			const fixedText = formatPlaceholders(text);
+			const quote = getStringOriginalQuote(node, sourceFile);
+			context.report({
+				fix: {
+					range: getTSNodeRange(node, sourceFile),
+					text: `${quote}${fixedText}${quote}`
+				},
+				message: "placeholderFormats",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
+			if (!isRuleCreatorCreateRule(node, typeChecker)) return;
+			const messagesProperty = findMessagesProperty(node);
+			if (!messagesProperty) return;
+			for (const ctx of forEachMessageString(messagesProperty)) checkStringLiteral(ctx.node, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/pluginRuleOrdering.ts
+function compareRuleNames(left, right) {
+	const leftLower = left.toLowerCase();
+	const rightLower = right.toLowerCase();
+	if (leftLower === rightLower) {
+		if (left === right) return 0;
+		return left < right ? -1 : 1;
+	}
+	return leftLower < rightLower ? -1 : 1;
+}
+function hasCommentsInArray(array, sourceFile) {
+	const arrayText = sourceFile.text.slice(array.getStart(sourceFile), array.getEnd());
+	return arrayText.includes("//") || arrayText.includes("/*");
+}
+function isCreatePluginCall(node, typeChecker) {
+	if (node.expression.kind !== SyntaxKind.Identifier) return false;
+	const symbol = typeChecker.getSymbolAtLocation(node.expression);
+	if (!symbol) return false;
+	const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol) : symbol;
+	if (resolvedSymbol.getName() !== "createPlugin") return false;
+	return resolvedSymbol.getDeclarations()?.some((declaration) => {
+		const fileName = declaration.getSourceFile().fileName.replaceAll("\\", "/");
+		return fileName.includes("/core/") && /plugins\/createPlugin\.(?:d\.)?[cm]?[jt]s$/.test(fileName);
+	});
+}
+var pluginRuleOrdering_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports Flint plugin `rules` arrays that are not sorted alphabetically.",
+		id: "pluginRuleOrdering",
+		presets: ["stylisticStrict"]
+	},
+	messages: { pluginRuleOrdering: {
+		primary: "Flint plugin rules should be listed in alphabetical order.",
+		secondary: ["Keeping plugin rule arrays sorted makes them easier to scan and update.", "This rule only checks `createPlugin({ rules: [...] })` arrays made of plain identifiers."],
+		suggestions: ["Sort the rules array alphabetically."]
+	} },
+	setup(context) {
+		function checkRulesArray(array, sourceFile) {
+			const elements = array.elements.filter((element) => element.kind === SyntaxKind.Identifier);
+			const firstElement = elements[0];
+			const lastElement = elements.at(-1);
+			if (!firstElement || !lastElement || firstElement === lastElement) return;
+			const names = elements.map((element) => element.text);
+			const sorted = [...names].toSorted(compareRuleNames);
+			const firstOutOfOrderIndex = names.findIndex((name, index) => name !== sorted[index]);
+			if (firstOutOfOrderIndex === -1) return;
+			const firstOutOfOrderElement = elements[firstOutOfOrderIndex];
+			if (!firstOutOfOrderElement) return;
+			const sortedElements = [...elements].sort((a, b) => compareRuleNames(a.text, b.text));
+			const fix = hasCommentsInArray(array, sourceFile) ? void 0 : [{
+				range: {
+					begin: firstElement.getStart(sourceFile),
+					end: lastElement.getEnd()
+				},
+				text: sortedElements.map((sorted, index) => {
+					const next = elements[index + 1];
+					const current = elements[index];
+					if (!current || !next) return sorted.text;
+					return sorted.text + sourceFile.text.slice(current.getEnd(), next.getStart(sourceFile));
+				}).join("")
+			}];
+			context.report({
+				fix,
+				message: "pluginRuleOrdering",
+				range: getTSNodeRange(firstOutOfOrderElement, sourceFile)
+			});
+		}
+		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
+			if (!isCreatePluginCall(node, typeChecker)) return;
+			const options = node.arguments[0];
+			if (options?.kind !== SyntaxKind.ObjectLiteralExpression) return;
+			const rulesProperty = findProperty(options.properties, "rules", (node) => node.kind === SyntaxKind.ArrayLiteralExpression);
+			if (!rulesProperty) return;
+			checkRulesArray(rulesProperty, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/ruleCreationMethods.ts
+var ruleCreationMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports plugin rules created directly with language instead of through RuleCreator.",
+		id: "ruleCreationMethods",
+		presets: ["logical"]
+	},
+	messages: { ruleCreationMethods: {
+		primary: "Plugin rules should be created through RuleCreator instead of calling language.createRule() directly.",
+		secondary: ["Direct language creation bypasses the standardized rule metadata and documentation provided by RuleCreator.", "RuleCreator adds the `docs` property and ensures consistent rule structure across plugins."],
+		suggestions: ["Create an instance of RuleCreator from `@flint.fyi/core` (e.g. `const ruleCreator = new RuleCreator({ presets: [...] })`), then use `ruleCreator.createRule(language, { ... })` instead of `language.createRule({ ... })`."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
+			if (!isLanguageCreateRule(node, typeChecker)) return;
+			context.report({
+				message: "ruleCreationMethods",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/testCaseDuplicates.ts
+var testCaseDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports test cases that are identical to previous test cases.",
+		id: "testCaseDuplicates",
+		presets: ["logical"]
+	},
+	messages: { duplicateTest: {
+		primary: "This test code already appeared in a previous test.",
+		secondary: ["When writing tests for lint rules, it's possible to accidentally create deeply identical test cases.", "Doing so provides no added benefit for testing and is unnecessary."],
+		suggestions: ["Delete this redundant test case.", "Change a property to make the test case unique."]
+	} },
+	setup(context) {
+		function checkTestCases(testCases, sourceFile) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const testCase of testCases) {
+				const key = JSON.stringify({
+					code: testCase.code,
+					fileName: testCase.fileName,
+					files: testCase.files,
+					options: testCase.options
+				});
+				if (seen.has(key)) context.report({
+					message: "duplicateTest",
+					range: getTSNodeRange(testCase.nodes.case, sourceFile)
+				});
+				else seen.add(key);
+			}
+		}
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const describedCases = getRuleTesterDescribedCases(node);
+			if (!describedCases) return;
+			checkTestCases(describedCases.invalid, sourceFile);
+			checkTestCases(describedCases.valid, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/testCaseNameDuplicates.ts
+var testCaseNameDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports test cases that have the same name as a previous test case.",
+		id: "testCaseNameDuplicates",
+		presets: ["logical"]
+	},
+	messages: { duplicateTestName: {
+		primary: "This test name already appeared in a previous test.",
+		secondary: ["When writing tests for lint rules, it's possible to accidentally give the same name to multiple test cases.", "Doing so makes it harder to identify failing tests in test log output."],
+		suggestions: ["Delete this redundant test case or give it a unique name."]
+	} },
+	setup(context) {
+		function checkTestCases(testCases, sourceFile) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const testCase of testCases) {
+				if (testCase.name == null || !testCase.nodes.name) continue;
+				if (seen.has(testCase.name)) context.report({
+					message: "duplicateTestName",
+					range: getTSNodeRange(testCase.nodes.name, sourceFile)
+				});
+				else seen.add(testCase.name);
+			}
+		}
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const describedCases = getRuleTesterDescribedCases(node);
+			if (!describedCases) return;
+			checkTestCases(describedCases.invalid, sourceFile);
+			checkTestCases(describedCases.valid, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/testCaseNonStaticCode.ts
+function getCodeProperty(node) {
+	return node.properties.find((property) => {
+		if (property.kind === SyntaxKind.PropertyAssignment) {
+			const name = property.name;
+			return (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.StringLiteral) && name.text === "code";
+		}
+		return property.kind === SyntaxKind.ShorthandPropertyAssignment && property.name.text === "code";
+	});
+}
+function isStaticString(node) {
+	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+function isStringRawNoSubstitution(node) {
+	if (node.kind !== SyntaxKind.TaggedTemplateExpression) return false;
+	const tag = node.tag;
+	return tag.kind === SyntaxKind.PropertyAccessExpression && tag.expression.kind === SyntaxKind.Identifier && tag.expression.text === "String" && tag.name.kind === SyntaxKind.Identifier && tag.name.text === "raw" && node.template.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+var testCaseNonStaticCode_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Test case code should be a static string literal.",
+		id: "testCaseNonStaticCode",
+		presets: ["logical"]
+	},
+	messages: { nonStaticTestCaseCode: {
+		primary: "Test case code should be a static string literal.",
+		secondary: ["Avoid generating test case code with variables, function calls, or template interpolations.", "Static strings keep test cases easy to audit and analyze with lint rules."],
+		suggestions: ["Replace the test case code with a static string literal."]
+	} },
+	setup(context) {
+		function checkTestCase(testCase, sourceFile) {
+			if (testCase.kind === SyntaxKind.OmittedExpression || isStaticString(testCase) || isStringRawNoSubstitution(testCase)) return;
+			if (testCase.kind !== SyntaxKind.ObjectLiteralExpression) {
+				const range = getTSNodeRange(testCase, sourceFile);
+				context.report({
+					message: "nonStaticTestCaseCode",
+					range
+				});
+				return;
+			}
+			const codeProperty = getCodeProperty(testCase);
+			if (!codeProperty) {
+				if (testCase.properties.some((node) => node.kind === SyntaxKind.SpreadAssignment)) {
+					const range = getTSNodeRange(testCase, sourceFile);
+					context.report({
+						message: "nonStaticTestCaseCode",
+						range
+					});
+				}
+				return;
+			}
+			if (codeProperty.kind === SyntaxKind.PropertyAssignment) {
+				if (isStaticString(codeProperty.initializer) || isStringRawNoSubstitution(codeProperty.initializer)) return;
+				const range = getTSNodeRange(codeProperty.initializer, sourceFile);
+				context.report({
+					message: "nonStaticTestCaseCode",
+					range
+				});
+				return;
+			}
+			if (codeProperty.kind === SyntaxKind.ShorthandPropertyAssignment) {
+				const range = getTSNodeRange(codeProperty.name, sourceFile);
+				context.report({
+					message: "nonStaticTestCaseCode",
+					range
+				});
+			}
+		}
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const testArrays = getRuleTesterCaseArrays(node);
+			if (!testArrays) return;
+			for (const testCase of [...testArrays.valid.elements, ...testArrays.invalid.elements]) checkTestCase(testCase, sourceFile);
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/testCaseOnlyFlags.ts
+var testCaseOnlyFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports test cases that are marked `only: true`.",
+		id: "testCaseOnlyFlags",
+		presets: ["logical"]
+	},
+	messages: { testCaseOnly: {
+		primary: "Do not commit test cases with `only: true`.",
+		secondary: ["The `only` flag is useful for local debugging, but it prevents the rest of the test suite from running.", "Leaving it in committed rule tests can hide failures in other test cases."],
+		suggestions: ["Remove the `only: true` property before committing."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const testArrays = getRuleTesterCaseArrays(node);
+			if (!testArrays) return;
+			for (const testCase of [...testArrays.valid.elements, ...testArrays.invalid.elements]) {
+				if (testCase.kind !== SyntaxKind.ObjectLiteralExpression) continue;
+				const onlyInitializer = findProperty(testCase.properties, "only", (node) => node.kind === SyntaxKind.TrueKeyword);
+				if (!onlyInitializer) continue;
+				context.report({
+					message: "testCaseOnly",
+					range: getTSNodeRange(onlyInitializer.parent, sourceFile)
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/testShorthands.ts
+var testShorthands_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Test cases with only a code property can use string shorthand syntax instead of object literal syntax.",
+		id: "testShorthands",
+		presets: ["logical"]
+	},
+	messages: { testShorthands: {
+		primary: "Use string shorthand for test cases with only a code property.",
+		secondary: ["String shorthand syntax is more concise: `valid: ['code here']` instead of `valid: [{ code: 'code here' }]`.", "Object literal syntax should be reserved for test cases with additional properties like fileName or options."],
+		suggestions: ["Switch the test case to shorthand syntax."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			const describedCases = getRuleTesterDescribedCases(node);
+			if (!describedCases) return;
+			for (const testCase of describedCases.valid) {
+				const caseNode = testCase.nodes.case;
+				if (ts.isObjectLiteralExpression(caseNode) && caseNode.properties.length === 1 && caseNode.properties[0]?.name && ts.isIdentifier(caseNode.properties[0].name) && caseNode.properties[0].name.text === "code") {
+					let fix;
+					if (ts.isPropertyAssignment(caseNode.properties[0])) fix = {
+						range: getTSNodeRange(caseNode, sourceFile),
+						text: caseNode.properties[0].initializer.getText(sourceFile)
+					};
+					context.report({
+						fix,
+						message: "testShorthands",
+						range: getTSNodeRange(caseNode.properties[0], sourceFile)
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+//#region src/utils/importHelpers.ts
+function isImportedBindingFromModule(declaration, moduleName) {
+	if (declaration.kind !== SyntaxKind.ImportSpecifier && declaration.kind !== SyntaxKind.NamespaceImport) return false;
+	const importDeclaration = declaration.kind === SyntaxKind.ImportSpecifier ? declaration.parent.parent.parent : declaration.parent.parent;
+	return isImportDeclaration(importDeclaration) && importDeclaration.moduleSpecifier.text === moduleName;
+}
+function isImportedSpecifierFromModule(declaration, moduleName, importedName) {
+	if (!isImportSpecifier(declaration) || !isImportedBindingFromModule(declaration, moduleName)) return false;
+	return (declaration.propertyName?.text ?? declaration.name.text) === importedName;
+}
+function isImportDeclaration(node) {
+	return node.kind === SyntaxKind.ImportDeclaration && node.moduleSpecifier.kind === SyntaxKind.StringLiteral;
+}
+function isImportSpecifier(node) {
+	return node.kind === SyntaxKind.ImportSpecifier;
+}
+//#endregion
+//#region src/rules/unusedMessageIds.ts
+const volarLanguagePackageName = "@flint.fyi/volar-language";
+function isVolarReportSourceCodeCall(node, typeChecker) {
+	if (node.expression.kind === SyntaxKind.Identifier) return typeChecker.getSymbolAtLocation(node.expression)?.getDeclarations()?.some((declaration) => isImportedSpecifierFromModule(declaration, volarLanguagePackageName, "reportSourceCode")) ?? false;
+	if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.name.text === "reportSourceCode") return typeChecker.getSymbolAtLocation(node.expression.expression)?.getDeclarations()?.some((declaration) => declaration.kind === SyntaxKind.NamespaceImport && isImportedBindingFromModule(declaration, volarLanguagePackageName)) ?? false;
+	return false;
+}
+//#endregion
+//#region src/plugin.ts
+const flint = createPlugin({
+	name: "Flint",
+	rules: [
+		getStartSourceFile_default,
+		invalidCodeLines_default,
+		missingPlaceholders_default,
+		nodePropertyInChecks_default,
+		placeholderFormats_default,
+		pluginRuleOrdering_default,
+		ruleCreationMethods_default,
+		testCaseDuplicates_default,
+		testCaseNameDuplicates_default,
+		testCaseNonStaticCode_default,
+		testCaseOnlyFlags_default,
+		testShorthands_default,
+		ruleCreator.createRule(typescriptLanguage, {
+			about: {
+				description: "Reports message IDs defined in the messages object that are never used in recognized report calls.",
+				id: "unusedMessageIds",
+				presets: ["logical"]
+			},
+			messages: { unusedMessageIds: {
+				primary: "Message ID '{{ messageId }}' is defined but never used.",
+				secondary: ["This message ID is declared in the messages object but is not referenced in any `context.report()` or built-in Flint report helper call.", "Remove unused message IDs to keep the rule configuration clean and maintainable."],
+				suggestions: ["Remove the unused message ID from the messages object."]
+			} },
+			setup(context) {
+				const unusedMessageIds = /* @__PURE__ */ new Map();
+				function collectMessageIds(node, sourceFile) {
+					const args = node.arguments[1];
+					if (args?.kind !== SyntaxKind.ObjectLiteralExpression) return;
+					const messagesProperty = findProperty(args.properties, "messages", (node) => node.kind === SyntaxKind.ObjectLiteralExpression);
+					if (!messagesProperty) return;
+					for (const prop of messagesProperty.properties) {
+						if (prop.kind !== SyntaxKind.PropertyAssignment || prop.name.kind !== SyntaxKind.Identifier) continue;
+						const messageId = prop.name.text;
+						if (!unusedMessageIds.has(messageId)) unusedMessageIds.set(messageId, getTSNodeRange(prop.name, sourceFile));
+					}
+				}
+				function detectMessageIdUsage(node, reportArgumentIndex) {
+					if (!unusedMessageIds.size) return;
+					const args = node.arguments[reportArgumentIndex];
+					if (args?.kind !== SyntaxKind.ObjectLiteralExpression) {
+						unusedMessageIds.clear();
+						return;
+					}
+					const messageProperty = findProperty(args.properties, "message", (node) => node.kind === SyntaxKind.StringLiteral);
+					if (!messageProperty) {
+						unusedMessageIds.clear();
+						return;
+					}
+					unusedMessageIds.delete(messageProperty.text);
+				}
+				return { visitors: {
+					CallExpression(node, { sourceFile, typeChecker }) {
+						if (isRuleCreatorCreateRule(node, typeChecker)) {
+							collectMessageIds(node, sourceFile);
+							return;
+						}
+						if (isRuleContextReport(node, typeChecker)) {
+							detectMessageIdUsage(node, 0);
+							return;
+						}
+						if (isVolarReportSourceCodeCall(node, typeChecker)) {
+							detectMessageIdUsage(node, 1);
+							return;
+						}
+					},
+					"SourceFile:exit"() {
+						if (!unusedMessageIds.size) return;
+						for (const [messageId, range] of unusedMessageIds) context.report({
+							data: { messageId },
+							message: "unusedMessageIds",
+							range
+						});
+						unusedMessageIds.clear();
+					}
+				} };
+			}
+		})
+	]
+});
+//#endregion
+export { flint };
+
 //# sourceMappingURL=index.js.map