@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/chainedAssignments.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
     readonly id: "chainedAssignments";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noChainedAssignment", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noChainedAssignment", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=chainedAssignments.d.ts.map

package/lib/rules/chainedAssignments.js

@@ -1,49 +1,33 @@
+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";
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
-import { unwrapParenthesizedExpressionsParent } from "../utils/unwrapParentParenthesizedExpressions.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using chained assignment expressions (e.g., a = b = c).",
-        id: "chainedAssignments",
-        preset: "stylistic",
-    },
-    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) => {
-                    if (!tsutils.isAssignmentKind(node.operatorToken.kind)) {
-                        return;
-                    }
-                    const rightSide = unwrapParenthesizedExpression(node.right);
-                    if (!ts.isBinaryExpression(rightSide) ||
-                        !tsutils.isAssignmentKind(rightSide.operatorToken.kind)) {
-                        return;
-                    }
-                    const parent = unwrapParenthesizedExpressionsParent(node);
-                    if (ts.isBinaryExpression(parent)) {
-                        return;
-                    }
-                    context.report({
-                        message: "noChainedAssignment",
-                        range: getTSNodeRange(node.operatorToken, context.sourceFile),
-                    });
-                },
-            },
-        };
-    },
+//#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

@@ -0,0 +1,10 @@
+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: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidComparison", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=charAtComparisons.d.ts.map

package/lib/rules/charAtComparisons.js

@@ -0,0 +1,58 @@
+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,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning class declarations.";
     readonly id: "classAssignments";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noClassAssign", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noClassAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=classAssignments.d.ts.map

package/lib/rules/classAssignments.js

@@ -1,42 +1,32 @@
-import { typescriptLanguage } from "../language.js";
-import { getModifyingReferences } from "../utils/getModifyingReferences.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports reassigning class declarations.",
-        id: "classAssignments",
-        preset: "untyped",
-    },
-    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) => {
-                    if (!node.name) {
-                        return;
-                    }
-                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
-                    for (const reference of modifyingReferences) {
-                        context.report({
-                            message: "noClassAssign",
-                            range: {
-                                begin: reference.getStart(context.sourceFile),
-                                end: reference.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getModifyingReferences, 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, typeChecker }) => {
+			if (!node.name) return;
+			const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
+			for (const reference of modifyingReferences) context.report({
+				message: "noClassAssign",
+				range: {
+					begin: reference.getStart(sourceFile),
+					end: reference.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { classAssignments_default as default };
+
+//# sourceMappingURL=classAssignments.js.map

package/lib/rules/classFieldDeclarations.d.ts

@@ -0,0 +1,10 @@
+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: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferClassField", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=classFieldDeclarations.d.ts.map

package/lib/rules/classFieldDeclarations.js

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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferField", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=classLiteralProperties.d.ts.map

package/lib/rules/classLiteralProperties.js

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

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

package/lib/rules/classMemberDuplicates.js

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

@@ -0,0 +1,14 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingThis", {
+    readonly ignoreClassesThatImplementAnInterface: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"public-fields">]>>;
+    readonly ignoreOverrideMethods: z.ZodDefault<z.ZodBoolean>;
+}>;
+export default _default;
+//# sourceMappingURL=classMethodsThis.d.ts.map

package/lib/rules/classMethodsThis.js

@@ -0,0 +1,124 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/classMethodsThis.ts
+function classImplementsSomething(classNode) {
+	return classNode.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword) ?? false;
+}
+function containsThis(node) {
+	switch (node.kind) {
+		case ts.SyntaxKind.ClassDeclaration:
+		case ts.SyntaxKind.ClassExpression: {
+			const classNode = node;
+			for (const member of classNode.members) if (ts.isPropertyDeclaration(member) && ts.isComputedPropertyName(member.name) && containsThis(member.name.expression)) return true;
+			return false;
+		}
+		case ts.SyntaxKind.ClassStaticBlockDeclaration:
+		case ts.SyntaxKind.FunctionDeclaration:
+		case ts.SyntaxKind.FunctionExpression: return false;
+		case ts.SyntaxKind.SuperKeyword:
+		case ts.SyntaxKind.ThisKeyword: return true;
+		default: return ts.forEachChild(node, containsThis) ?? false;
+	}
+}
+function getMemberDisplayName(member, sourceFile) {
+	const name = member.name;
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	if (ts.isPrivateIdentifier(name)) return name.text;
+	if (ts.isComputedPropertyName(name)) {
+		const expr = name.expression;
+		if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr) || ts.isNumericLiteral(expr)) return expr.text;
+		return `[${expr.getText(sourceFile)}]`;
+	}
+}
+function hasModifier(modifiers, kind) {
+	return modifiers?.some((modifier) => modifier.kind === kind) ?? false;
+}
+function isPublicMember(member) {
+	if (ts.isPrivateIdentifier(member.name)) return false;
+	const modifiers = member.modifiers;
+	if (!modifiers) return true;
+	if (modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) return false;
+	return true;
+}
+function shouldSkipMember(member, classNode, options) {
+	if (hasModifier(member.modifiers, ts.SyntaxKind.StaticKeyword)) return true;
+	if (options.ignoreOverrideMethods && hasModifier(member.modifiers, ts.SyntaxKind.OverrideKeyword)) return true;
+	const implementsInterface = classImplementsSomething(classNode);
+	const ignoreImpl = options.ignoreClassesThatImplementAnInterface;
+	if (implementsInterface && ignoreImpl) {
+		if (ignoreImpl === true) return true;
+		if (isPublicMember(member)) return true;
+	}
+	return false;
+}
+var classMethodsThis_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports class methods that do not use `this`.",
+		id: "classMethodsThis",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { missingThis: {
+		primary: "Expected 'this' to be used by class {{ kind }} '{{ name }}'.",
+		secondary: ["Methods that don't use `this` could be static methods or standalone functions.", "Using instance methods that don't access instance state can be misleading."],
+		suggestions: ["Add the `static` keyword to make this a static method.", "Extract this to a standalone function if it doesn't need class context."]
+	} },
+	options: {
+		ignoreClassesThatImplementAnInterface: z.union([z.boolean(), z.literal("public-fields")]).default(false).describe("Whether to ignore classes that implement interfaces. Set to 'public-fields' to only ignore public members."),
+		ignoreOverrideMethods: z.boolean().default(false).describe("Whether to ignore members with the 'override' modifier.")
+	},
+	setup(context) {
+		function reportMember(member, kind, sourceFile, reportFromStart) {
+			const name = getMemberDisplayName(member, sourceFile);
+			if (!name) return;
+			const beginNode = reportFromStart ? member : member.name;
+			context.report({
+				data: {
+					kind,
+					name
+				},
+				message: "missingThis",
+				range: {
+					begin: beginNode.getStart(sourceFile),
+					end: member.name.getEnd()
+				}
+			});
+		}
+		function checkMethod(member, classNode, sourceFile, options) {
+			if (member.body && !shouldSkipMember(member, classNode, options) && !containsThis(member.body)) reportMember(member, "method", sourceFile, false);
+		}
+		function checkAccessor(member, classNode, sourceFile, options, kind) {
+			if (member.body && !shouldSkipMember(member, classNode, options) && !containsThis(member.body)) reportMember(member, kind, sourceFile, true);
+		}
+		function checkPropertyInitializerFunction(member, classNode, sourceFile, options) {
+			if (!member.initializer) return;
+			if (member.initializer.kind !== ts.SyntaxKind.ArrowFunction && member.initializer.kind !== ts.SyntaxKind.FunctionExpression) return;
+			if (!shouldSkipMember(member, classNode, options) && !containsThis(member.initializer.body)) reportMember(member, "method", sourceFile, false);
+		}
+		function checkClass(node, { options, sourceFile }) {
+			for (const member of node.members) switch (member.kind) {
+				case ts.SyntaxKind.GetAccessor:
+					checkAccessor(member, node, sourceFile, options, "getter");
+					break;
+				case ts.SyntaxKind.MethodDeclaration:
+					checkMethod(member, node, sourceFile, options);
+					break;
+				case ts.SyntaxKind.PropertyDeclaration:
+					checkPropertyInitializerFunction(member, node, sourceFile, options);
+					break;
+				case ts.SyntaxKind.SetAccessor:
+					checkAccessor(member, node, sourceFile, options, "setter");
+					break;
+			}
+		}
+		return { visitors: {
+			ClassDeclaration: checkClass,
+			ClassExpression: checkClass
+		} };
+	}
+});
+//#endregion
+export { classMethodsThis_default as default };
+
+//# sourceMappingURL=classMethodsThis.js.map

package/lib/rules/combinedPushes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports consecutive array.push() calls that could be combined into a single call.";
+    readonly id: "combinedPushes";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "combinePushes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=combinedPushes.d.ts.map