@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/caseFallthroughs.js

@@ -1,76 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/caseFallthroughs.ts
-const fallthroughCommentPattern = /falls?\s*through/i;
-function endsWithTerminatingStatement(statements) {
-	return !!statements.length && isTerminatingStatement(statements.at(-1));
-}
-function hasFallthroughComment(clause, nextClause, sourceFile) {
-	const sourceText = sourceFile.getFullText();
-	const commentRanges = ts$1.getLeadingCommentRanges(sourceText, nextClause.getFullStart());
-	if (commentRanges) for (const range of commentRanges) {
-		const comment = sourceText.slice(range.pos, range.end);
-		if (fallthroughCommentPattern.test(comment)) return true;
-	}
-	const trailingRanges = ts$1.getTrailingCommentRanges(sourceText, clause.getEnd());
-	if (trailingRanges) for (const range of trailingRanges) {
-		const comment = sourceText.slice(range.pos, range.end);
-		if (fallthroughCommentPattern.test(comment)) return true;
-	}
-	return false;
-}
-function isTerminatingStatement(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.Block: return endsWithTerminatingStatement(node.statements);
-		case ts$1.SyntaxKind.BreakStatement:
-		case ts$1.SyntaxKind.ContinueStatement:
-		case ts$1.SyntaxKind.ReturnStatement:
-		case ts$1.SyntaxKind.ThrowStatement: return true;
-		case ts$1.SyntaxKind.IfStatement: return !!node.elseStatement && isTerminatingStatement(node.thenStatement) && isTerminatingStatement(node.elseStatement);
-		case ts$1.SyntaxKind.SwitchStatement: return node.caseBlock.clauses.some(ts$1.isDefaultClause) && node.caseBlock.clauses.every((clause) => !clause.statements.length || endsWithTerminatingStatement(clause.statements));
-		case ts$1.SyntaxKind.TryStatement:
-			if (node.finallyBlock) return endsWithTerminatingStatement(node.finallyBlock.statements);
-			if (!node.catchClause) return endsWithTerminatingStatement(node.tryBlock.statements);
-			return endsWithTerminatingStatement(node.tryBlock.statements) && endsWithTerminatingStatement(node.catchClause.block.statements);
-		default: return false;
-	}
-}
-var caseFallthroughs_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports switch case clauses that fall through unexpectedly.",
-		id: "caseFallthroughs",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unexpectedFallthrough: {
-		primary: "This case falls through to the next case without a break, return, or throw statement.",
-		secondary: ["Fallthrough in switch statements is often unintentional and can lead to bugs.", "If fallthrough is intentional, add a comment containing 'falls through' to indicate this."],
-		suggestions: [
-			"Add a `break` statement at the end of this case.",
-			"Add a `return` or `throw` statement if appropriate.",
-			"If fallthrough is intentional, add a `// falls through` comment."
-		]
-	} },
-	setup(context) {
-		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
-			for (let i = 0; i < node.caseBlock.clauses.length - 1; i++) {
-				const clause = node.caseBlock.clauses[i];
-				if (!clause) continue;
-				const nextClause = node.caseBlock.clauses[i + 1];
-				if (!clause.statements.length || endsWithTerminatingStatement(clause.statements) || hasFallthroughComment(clause, nextClause, sourceFile)) continue;
-				const caseKeyword = ts$1.isCaseClause(clause) ? "case" : "default";
-				context.report({
-					message: "unexpectedFallthrough",
-					range: {
-						begin: clause.getStart(sourceFile),
-						end: clause.getStart(sourceFile) + caseKeyword.length
-					}
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { caseFallthroughs_default as default };
-
-//# sourceMappingURL=caseFallthroughs.js.map

package/lib/rules/catchCallbackTypes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `Promise` catch callback parameters that are not typed as unknown.";
-    readonly id: "catchCallbackTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferUnknown", undefined>;
-export default _default;
-//# sourceMappingURL=catchCallbackTypes.d.ts.map

package/lib/rules/catchCallbackTypes.js

@@ -1,67 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { declarationIncludesGlobal, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/catchCallbackTypes.ts
-var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `Promise` catch callback parameters that are not typed as unknown.",
-		id: "catchCallbackTypes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferUnknown: {
-		primary: "The catch callback parameter should be typed as the safer `unknown` instead of `any`.",
-		secondary: [
-			"TypeScript's `useUnknownInCatchVariables` option only affects synchronous catch clauses, not Promise callbacks.",
-			"Promise rejection values can be anything, so using `unknown` forces proper type narrowing before use.",
-			"Using `any` in catch callbacks undermines type safety and can lead to runtime errors."
-		],
-		suggestions: ["Add an explicit `: unknown` type annotation to the callback parameter."]
-	} },
-	setup(context) {
-		function isGlobalPromiseType(type) {
-			const symbol = type.getSymbol();
-			if (symbol?.getName() !== "Promise") return false;
-			const declarations = symbol.getDeclarations();
-			if (!declarations) return false;
-			return declarations.some((declaration) => ts$1.isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration));
-		}
-		function isCatchOrThenCallback(node, typeChecker) {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			const methodName = node.expression.name.text;
-			if (methodName !== "catch" && methodName !== "then") return;
-			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker))) return;
-			return methodName === "catch" ? "catch" : "then";
-		}
-		function checkCallbackParameter(callback, sourceFile, typeChecker) {
-			if (!ts$1.isFunctionLike(callback) || !callback.parameters.length) return;
-			const firstParameter = callback.parameters[0];
-			if (firstParameter.type) {
-				const paramType = typeChecker.getTypeFromTypeNode(firstParameter.type);
-				if (tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Unknown) || !tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Any)) return;
-			}
-			context.report({
-				message: "preferUnknown",
-				range: {
-					begin: firstParameter.name.getStart(sourceFile),
-					end: firstParameter.type ? firstParameter.type.getEnd() : firstParameter.name.getEnd()
-				}
-			});
-		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			switch (isCatchOrThenCallback(node, typeChecker)) {
-				case "catch":
-					if (node.arguments.length >= 1) checkCallbackParameter(node.arguments[0], sourceFile, typeChecker);
-					break;
-				case "then":
-					if (node.arguments.length >= 2) checkCallbackParameter(node.arguments[1], sourceFile, typeChecker);
-					break;
-			}
-		} } };
-	}
-});
-//#endregion
-export { catchCallbackTypes_default as default };
-
-//# sourceMappingURL=catchCallbackTypes.js.map

package/lib/rules/caughtVariableNames.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces a consistent naming convention for catch clause error variables.";
-    readonly id: "caughtVariableNames";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferErrorName", undefined>;
-export default _default;
-//# sourceMappingURL=caughtVariableNames.d.ts.map

package/lib/rules/caughtVariableNames.js

@@ -1,40 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/caughtVariableNames.ts
-var caughtVariableNames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces a consistent naming convention for catch clause error variables.",
-		id: "caughtVariableNames",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferErrorName: {
-		primary: "Use `error` as the name for the catch clause parameter instead of `{{ name }}`.",
-		secondary: [
-			"Consistent naming of catch clause parameters improves code readability.",
-			"The name `error` clearly indicates the purpose of the variable.",
-			"Descriptive names ending in 'Error' are generally also acceptable."
-		],
-		suggestions: ["Rename `{{ name }}` to `error`.", "Rename `{{ name }}` to a name ending with `Error`."]
-	} },
-	setup(context) {
-		return { visitors: { CatchClause: (node, { sourceFile }) => {
-			const variable = node.variableDeclaration;
-			if (!variable || !ts$1.isIdentifier(variable.name)) return;
-			const name = variable.name.text;
-			if (name === "error" || name.endsWith("Error")) return;
-			context.report({
-				data: { name },
-				message: "preferErrorName",
-				range: {
-					begin: variable.name.getStart(sourceFile),
-					end: variable.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { caughtVariableNames_default as default };
-
-//# sourceMappingURL=caughtVariableNames.js.map

package/lib/rules/chainedAssignments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
-    readonly id: "chainedAssignments";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noChainedAssignment", undefined>;
-export default _default;
-//# sourceMappingURL=chainedAssignments.d.ts.map

package/lib/rules/chainedAssignments.js

@@ -1,33 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/chainedAssignments.ts
-var chainedAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using chained assignment expressions (e.g., a = b = c).",
-		id: "chainedAssignments",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { noChainedAssignment: {
-		primary: "Prefer separate assignment statements for readability instead of chaining assignments.",
-		secondary: ["Chained assignments can be hard to read and can lead to unexpected behavior with variable scoping and type inference.", "Each assignment creates a reference to the same value, which may cause confusion when dealing with mutable values."],
-		suggestions: ["Break the chained assignment into separate assignment statements, one for each variable."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!tsutils.isAssignmentKind(node.operatorToken.kind)) return;
-			const rightSide = unwrapParenthesizedNode(node.right);
-			if (rightSide.kind !== SyntaxKind.BinaryExpression || !tsutils.isAssignmentKind(rightSide.operatorToken.kind)) return;
-			if (unwrapParentParenthesizedExpressions(node).kind === SyntaxKind.BinaryExpression) return;
-			context.report({
-				message: "noChainedAssignment",
-				range: getTSNodeRange(node.operatorToken, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { chainedAssignments_default as default };
-
-//# sourceMappingURL=chainedAssignments.js.map

package/lib/rules/charAtComparisons.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparing charAt() results with strings longer than one character.";
-    readonly id: "charAtComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidComparison", undefined>;
-export default _default;
-//# sourceMappingURL=charAtComparisons.d.ts.map

package/lib/rules/charAtComparisons.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/charAtComparisons.ts
-const comparisonOperators = new Set([
-	ts$1.SyntaxKind.EqualsEqualsEqualsToken,
-	ts$1.SyntaxKind.EqualsEqualsToken,
-	ts$1.SyntaxKind.ExclamationEqualsEqualsToken,
-	ts$1.SyntaxKind.ExclamationEqualsToken
-]);
-function getStringLiteralLength(node) {
-	return ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node) ? node.text.length : void 0;
-}
-function isStringCharAtCall(node, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "charAt" && isStringType(typeChecker.getTypeAtLocation(node.expression.expression));
-}
-function isStringType(type) {
-	return (type.flags & ts$1.TypeFlags.StringLike) !== 0;
-}
-var charAtComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparing charAt() results with strings longer than one character.",
-		id: "charAtComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { invalidComparison: {
-		primary: "Comparing charAt() result with a string of length {{ length }} is always {{ result }}.",
-		secondary: ["The `charAt` method returns a string of exactly one character.", "Comparing it with a multi-character string will always evaluate to the same result."],
-		suggestions: ["Use a single-character string for the comparison.", "Consider using `startsWith()`, `includes()`, or `slice()` for multi-character comparisons."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
-			if (!comparisonOperators.has(node.operatorToken.kind)) return;
-			let literal;
-			if (isStringCharAtCall(node.left, typeChecker)) literal = node.right;
-			else if (isStringCharAtCall(node.right, typeChecker)) literal = node.left;
-			else return;
-			const length = getStringLiteralLength(literal);
-			if (length === void 0 || length <= 1) return;
-			const isEquality = node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken;
-			context.report({
-				data: {
-					length,
-					result: isEquality ? "false" : "true"
-				},
-				message: "invalidComparison",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { charAtComparisons_default as default };
-
-//# sourceMappingURL=charAtComparisons.js.map

package/lib/rules/classAssignments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports reassigning class declarations.";
-    readonly id: "classAssignments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noClassAssign", undefined>;
-export default _default;
-//# sourceMappingURL=classAssignments.d.ts.map

package/lib/rules/classAssignments.js

@@ -1,29 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/classAssignments.ts
-var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports reassigning class declarations.",
-		id: "classAssignments",
-		presets: ["javascript"]
-	},
-	messages: { noClassAssign: {
-		primary: "Reassigning a class declaration is misleading and makes the class harder to use.",
-		secondary: ["Reassigning a class declaration can lead to unexpected behavior and makes code harder to understand.", "Class declarations are typically intended to be immutable references, and reassigning them can cause confusion about which class is being used."],
-		suggestions: ["Use a different variable name if you need to store a modified reference to a class."]
-	} },
-	setup(context) {
-		return { visitors: { ClassDeclaration: (node, { sourceFile }) => {
-			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
-			for (const reference of modifyingReferences) context.report({
-				message: "noClassAssign",
-				range: getTSNodeRange(reference, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { classAssignments_default as default };
-
-//# sourceMappingURL=classAssignments.js.map

package/lib/rules/classFieldDeclarations.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports assigning literal values to `this` in constructors instead of using class field declarations.";
-    readonly id: "classFieldDeclarations";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferClassField", undefined>;
-export default _default;
-//# sourceMappingURL=classFieldDeclarations.d.ts.map

package/lib/rules/classFieldDeclarations.js

@@ -1,40 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/classFieldDeclarations.ts
-function isLiteralValue(node) {
-	if (ts.isPrefixUnaryExpression(node)) return isLiteralValue(node.operand);
-	return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isLiteralExpression(node);
-}
-function isThisLiteralAssignment(node) {
-	return (ts.isElementAccessExpression(node.left) || ts.isPropertyAccessExpression(node.left)) && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && isLiteralValue(node.right);
-}
-var classFieldDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports assigning literal values to `this` in constructors instead of using class field declarations.",
-		id: "classFieldDeclarations",
-		presets: ["javascript"]
-	},
-	messages: { preferClassField: {
-		primary: "Prefer class field declaration over `this` assignment in constructor for static values.",
-		secondary: ["Class field declarations are more concise and clearly express the intent of initializing properties.", "Moving property initialization to class fields keeps the constructor focused on dynamic initialization logic."],
-		suggestions: ["Move this property assignment to a class field declaration."]
-	} },
-	setup(context) {
-		function checkStatement(node, sourceFile) {
-			if (!ts.isExpressionStatement(node) || !ts.isBinaryExpression(node.expression) || node.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !isThisLiteralAssignment(node.expression)) return;
-			context.report({
-				message: "preferClassField",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: { Constructor: (node, { sourceFile }) => {
-			if (!node.body || !ts.isClassDeclaration(node.parent) && !ts.isClassExpression(node.parent)) return;
-			for (const statement of node.body.statements) checkStatement(statement, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { classFieldDeclarations_default as default };
-
-//# sourceMappingURL=classFieldDeclarations.js.map

package/lib/rules/classLiteralProperties.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports getters that return literal values instead of using readonly class fields.";
-    readonly id: "classLiteralProperties";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferField", undefined>;
-export default _default;
-//# sourceMappingURL=classLiteralProperties.d.ts.map

package/lib/rules/classLiteralProperties.js

@@ -1,45 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/classLiteralProperties.ts
-var classLiteralProperties_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports getters that return literal values instead of using readonly class fields.",
-		id: "classLiteralProperties",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferField: {
-		primary: "Prefer a readonly class field over a getter returning a literal value.",
-		secondary: ["Readonly fields are more concise and avoid the overhead of a function call.", "Getters returning literal values provide no benefit over readonly fields."],
-		suggestions: ["Replace this getter with a readonly field."]
-	} },
-	setup(context) {
-		return { visitors: { GetAccessor: (node, { sourceFile }) => {
-			if (node.body?.statements.length !== 1) return;
-			const statement = node.body.statements[0];
-			if (!ts.isReturnStatement(statement) || !statement.expression || !isLiteralValue(statement.expression)) return;
-			context.report({
-				message: "preferField",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-function isLiteralValue(node) {
-	switch (node.kind) {
-		case ts.SyntaxKind.BigIntLiteral:
-		case ts.SyntaxKind.FalseKeyword:
-		case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
-		case ts.SyntaxKind.NullKeyword:
-		case ts.SyntaxKind.NumericLiteral:
-		case ts.SyntaxKind.RegularExpressionLiteral:
-		case ts.SyntaxKind.StringLiteral:
-		case ts.SyntaxKind.TrueKeyword: return true;
-		case ts.SyntaxKind.PrefixUnaryExpression: return isLiteralValue(node.operand);
-		default: return false;
-	}
-}
-//#endregion
-export { classLiteralProperties_default as default };
-
-//# sourceMappingURL=classLiteralProperties.js.map

package/lib/rules/classMemberDuplicates.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports duplicate class member names that will be overwritten.";
-    readonly id: "classMemberDuplicates";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateMember", undefined>;
-export default _default;
-//# sourceMappingURL=classMemberDuplicates.d.ts.map

package/lib/rules/classMemberDuplicates.js

@@ -1,71 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/classMemberDuplicates.ts
-var classMemberDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports duplicate class member names that will be overwritten.",
-		id: "classMemberDuplicates",
-		presets: ["javascript"]
-	},
-	messages: { duplicateMember: {
-		primary: "Duplicate class member name '{{ memberName }}' will be overwritten.",
-		secondary: ["Duplicate class members are legal in JavaScript, but only the last definition is used.", "This can lead to confusion and bugs, especially when maintaining the code."],
-		suggestions: ["If both members are meant to exist, rename one of them.", "If only the last definition is meant to exist, remove the earlier one."]
-	} },
-	setup(context) {
-		return { visitors: {
-			ClassDeclaration: visitClass,
-			ClassExpression: visitClass
-		} };
-		function visitClass(node, { sourceFile }) {
-			const seenMembers = {
-				instance: {
-					getters: /* @__PURE__ */ new Map(),
-					setters: /* @__PURE__ */ new Map(),
-					values: /* @__PURE__ */ new Map()
-				},
-				static: {
-					getters: /* @__PURE__ */ new Map(),
-					setters: /* @__PURE__ */ new Map(),
-					values: /* @__PURE__ */ new Map()
-				}
-			};
-			for (const member of node.members.toReversed()) {
-				const key = getMemberKeyName(member);
-				if (!key) continue;
-				const namespace = key.isStatic ? seenMembers.static : seenMembers.instance;
-				let isDuplicate;
-				if (key.group === "values") isDuplicate = namespace.values.has(key.text) || namespace.getters.has(key.text) || namespace.setters.has(key.text);
-				else if (key.group === "getters") isDuplicate = namespace.getters.has(key.text) || namespace.values.has(key.text);
-				else isDuplicate = namespace.setters.has(key.text) || namespace.values.has(key.text);
-				if (isDuplicate) context.report({
-					data: { memberName: key.text },
-					message: "duplicateMember",
-					range: getTSNodeRange(key.node, sourceFile)
-				});
-				namespace[key.group].set(key.text, member);
-			}
-		}
-	}
-});
-function getMemberKeyName(member) {
-	if (member.kind === SyntaxKind.PropertyDeclaration || member.kind === SyntaxKind.MethodDeclaration || member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) {
-		const text = getNameText(member.name);
-		if (!text) return;
-		const isStatic = member.modifiers?.some((modifier) => modifier.kind === SyntaxKind.StaticKeyword);
-		return {
-			group: member.kind === SyntaxKind.GetAccessor ? "getters" : member.kind === SyntaxKind.SetAccessor ? "setters" : "values",
-			isStatic: !!isStatic,
-			node: member.name,
-			text
-		};
-	}
-}
-function getNameText(name) {
-	if (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.NumericLiteral || name.kind === SyntaxKind.BigIntLiteral || name.kind === SyntaxKind.StringLiteral || name.kind === SyntaxKind.NoSubstitutionTemplateLiteral || name.kind === SyntaxKind.PrivateIdentifier) return name.text;
-}
-//#endregion
-export { classMemberDuplicates_default as default };
-
-//# sourceMappingURL=classMemberDuplicates.js.map

package/lib/rules/classMethodsThis.d.ts

@@ -1,14 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports class methods that do not use `this`.";
-    readonly id: "classMethodsThis";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingThis", {
-    ignoreClassesThatImplementAnInterface: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"public-fields">]>>;
-    ignoreOverrideMethods: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;
-//# sourceMappingURL=classMethodsThis.d.ts.map