@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/shadowedRestrictedNames.js

@@ -1,95 +1,68 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/shadowedRestrictedNames.ts
 const restrictedNames = new Set([
-    "arguments",
-    "eval",
-    "Infinity",
-    "NaN",
-    "undefined",
+	"arguments",
+	"eval",
+	"Infinity",
+	"NaN",
+	"undefined"
 ]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports variable declarations that shadow JavaScript's restricted names.",
-        id: "shadowedRestrictedNames",
-        preset: "untyped",
-    },
-    messages: {
-        shadowedRestrictedName: {
-            primary: "This variable misleadingly shadows the global `{{ name }}`.",
-            secondary: [
-                "JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.",
-                "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior.",
-            ],
-            suggestions: [
-                "Use a different variable name that doesn't shadow a restricted name.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkIdentifier(node) {
-            if (restrictedNames.has(node.text)) {
-                context.report({
-                    data: {
-                        name: node.text,
-                    },
-                    message: "shadowedRestrictedName",
-                    range: getTSNodeRange(node, context.sourceFile),
-                });
-            }
-        }
-        function checkBindingName(name) {
-            if (ts.isIdentifier(name)) {
-                checkIdentifier(name);
-            }
-            else if (ts.isObjectBindingPattern(name) ||
-                ts.isArrayBindingPattern(name)) {
-                for (const element of name.elements) {
-                    if (ts.isBindingElement(element)) {
-                        checkBindingName(element.name);
-                    }
-                }
-            }
-        }
-        function checkParameters(parameters) {
-            for (const parameter of parameters) {
-                checkBindingName(parameter.name);
-            }
-        }
-        return {
-            visitors: {
-                ArrowFunction: (node) => {
-                    checkParameters(node.parameters);
-                },
-                ClassDeclaration: (node) => {
-                    if (node.name) {
-                        checkIdentifier(node.name);
-                    }
-                },
-                ClassExpression: (node) => {
-                    if (node.name) {
-                        checkIdentifier(node.name);
-                    }
-                },
-                FunctionDeclaration: (node) => {
-                    if (node.name) {
-                        checkIdentifier(node.name);
-                    }
-                    checkParameters(node.parameters);
-                },
-                FunctionExpression: (node) => {
-                    if (node.name) {
-                        checkIdentifier(node.name);
-                    }
-                    checkParameters(node.parameters);
-                },
-                MethodDeclaration: (node) => {
-                    checkParameters(node.parameters);
-                },
-                VariableDeclaration: (node) => {
-                    checkBindingName(node.name);
-                },
-            },
-        };
-    },
+var shadowedRestrictedNames_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports variable declarations that shadow JavaScript's restricted names.",
+		id: "shadowedRestrictedNames",
+		presets: ["javascript"]
+	},
+	messages: { shadowedRestrictedName: {
+		primary: "This variable misleadingly shadows the global `{{ name }}`.",
+		secondary: ["JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.", "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior."],
+		suggestions: ["Use a different variable name that doesn't shadow a restricted name."]
+	} },
+	setup(context) {
+		function checkIdentifier(node, sourceFile) {
+			if (restrictedNames.has(node.text)) context.report({
+				data: { name: node.text },
+				message: "shadowedRestrictedName",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		function checkBindingName(name, sourceFile) {
+			if (name.kind === SyntaxKind.Identifier) checkIdentifier(name, sourceFile);
+			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) checkBindingName(element.name, sourceFile);
+		}
+		function checkParameters(parameters, sourceFile) {
+			for (const parameter of parameters) checkBindingName(parameter.name, sourceFile);
+		}
+		return { visitors: {
+			ArrowFunction: (node, { sourceFile }) => {
+				checkParameters(node.parameters, sourceFile);
+			},
+			ClassDeclaration: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+			},
+			ClassExpression: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+			},
+			FunctionDeclaration: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+				checkParameters(node.parameters, sourceFile);
+			},
+			FunctionExpression: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+				checkParameters(node.parameters, sourceFile);
+			},
+			MethodDeclaration: (node, { sourceFile }) => {
+				checkParameters(node.parameters, sourceFile);
+			},
+			VariableDeclaration: (node, { sourceFile }) => {
+				checkBindingName(node.name, sourceFile);
+			}
+		} };
+	}
 });
+//#endregion
+export { shadowedRestrictedNames_default as default };
+
+//# sourceMappingURL=shadowedRestrictedNames.js.map

package/lib/rules/singleVariableDeclarations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces one variable per declaration statement.";
+    readonly id: "singleVariableDeclarations";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "singleVariable", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=singleVariableDeclarations.d.ts.map

package/lib/rules/singleVariableDeclarations.js

@@ -0,0 +1,36 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/singleVariableDeclarations.ts
+var singleVariableDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces one variable per declaration statement.",
+		id: "singleVariableDeclarations",
+		presets: ["logical"]
+	},
+	messages: { singleVariable: {
+		primary: "Split this into separate variable declarations.",
+		secondary: ["Declaring multiple variables in one statement can reduce readability."],
+		suggestions: ["Use separate declaration statements for each variable."]
+	} },
+	setup(context) {
+		return { visitors: {
+			ForStatement: (node, { sourceFile }) => {
+				if (node.initializer && ts.isVariableDeclarationList(node.initializer) && node.initializer.declarations.length > 1) context.report({
+					message: "singleVariable",
+					range: getTSNodeRange(node.initializer, sourceFile)
+				});
+			},
+			VariableStatement: (node, { sourceFile }) => {
+				if (node.declarationList.declarations.length > 1) context.report({
+					message: "singleVariable",
+					range: getTSNodeRange(node.declarationList, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { singleVariableDeclarations_default as default };
+
+//# sourceMappingURL=singleVariableDeclarations.js.map

package/lib/rules/sizeComparisonOperators.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforce consistent style for `.length` and `.size` checks.";
+    readonly id: "sizeComparisonOperators";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "coercionNonZeroCheck" | "coercionZeroCheck" | "explicitNonZeroCheck" | "explicitZeroCheck", {
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        coercion: "coercion";
+        explicit: "explicit";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=sizeComparisonOperators.d.ts.map

package/lib/rules/sizeComparisonOperators.js

@@ -0,0 +1,148 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/sizeComparisonOperators.ts
+const sizePropertyNames = new Set(["length", "size"]);
+function hasLogicalOrFallback(node) {
+	return ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken && node.parent.left === node;
+}
+function isDoubleNegation(node) {
+	return ts$1.isPrefixUnaryExpression(node) && node.operator === ts$1.SyntaxKind.ExclamationToken && ts$1.isPrefixUnaryExpression(node.operand) && node.operand.operator === ts$1.SyntaxKind.ExclamationToken;
+}
+function isInBooleanContext(node) {
+	if (isDoubleNegation(node)) return true;
+	switch (node.parent.kind) {
+		case ts$1.SyntaxKind.BinaryExpression: return node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken && node.parent.left === node;
+		case ts$1.SyntaxKind.CallExpression: return ts$1.isIdentifier(node.parent.expression) && node.parent.expression.text === "Boolean" && node.parent.arguments.length === 1 && node.parent.arguments[0] === node;
+		case ts$1.SyntaxKind.ConditionalExpression:
+		case ts$1.SyntaxKind.ForStatement: return node.parent.condition === node;
+		case ts$1.SyntaxKind.DoStatement:
+		case ts$1.SyntaxKind.IfStatement:
+		case ts$1.SyntaxKind.WhileStatement: return node.parent.expression === node;
+		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts$1.SyntaxKind.ExclamationToken;
+		default: return false;
+	}
+}
+function isInNullishCoalescing(node) {
+	return ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.QuestionQuestionToken;
+}
+function isNegated(node) {
+	if (!ts$1.isPrefixUnaryExpression(node.parent) || node.parent.operator !== ts$1.SyntaxKind.ExclamationToken) return {
+		negated: false,
+		outerNode: node
+	};
+	if (ts$1.isPrefixUnaryExpression(node.parent.parent) && node.parent.parent.operator === ts$1.SyntaxKind.ExclamationToken) return {
+		negated: false,
+		outerNode: node.parent.parent
+	};
+	return {
+		negated: true,
+		outerNode: node.parent
+	};
+}
+function requiresBooleanType(node) {
+	switch (node.parent.kind) {
+		case ts$1.SyntaxKind.ArrowFunction:
+		case ts$1.SyntaxKind.PropertyDeclaration:
+		case ts$1.SyntaxKind.ReturnStatement:
+		case ts$1.SyntaxKind.VariableDeclaration: return true;
+		case ts$1.SyntaxKind.BinaryExpression:
+			if (node.parent.operatorToken.kind === ts$1.SyntaxKind.EqualsToken && node.parent.right === node) return true;
+			if (node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken) return node.parent.right === node;
+			return false;
+		case ts$1.SyntaxKind.ParenthesizedExpression: return requiresBooleanType(node.parent.expression);
+	}
+	return false;
+}
+var sizeComparisonOperators_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforce consistent style for `.length` and `.size` checks.",
+		id: "sizeComparisonOperators",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		coercionNonZeroCheck: {
+			primary: "Prefer implicit boolean coercions instead of explicit `> 0` comparisons.",
+			secondary: ["Implicit boolean coercion of `.{{ property }}` is more concise."],
+			suggestions: ["Replace with `.{{ property }}`."]
+		},
+		coercionZeroCheck: {
+			primary: "Prefer implicit boolean coercions instead of explicit `=== 0` comparisons.",
+			secondary: ["Implicit boolean coercion of `.{{ property }}` is more concise."],
+			suggestions: ["Replace with `!.{{ property }}`."]
+		},
+		explicitNonZeroCheck: {
+			primary: "Prefer explicit `> 0` comparisons instead of implicit boolean coercions.",
+			secondary: ["Implicit boolean coercion of `.{{ property }}` can be confusing."],
+			suggestions: ["Replace with `.{{ property }} > 0`."]
+		},
+		explicitZeroCheck: {
+			primary: "Prefer explicit `=== 0` comparisons instead of implicit boolean coercions.",
+			secondary: ["Implicit boolean coercion of `.{{ property }}` can be confusing."],
+			suggestions: ["Replace with `.{{ property }} === 0`."]
+		}
+	},
+	options: { style: z.enum(["coercion", "explicit"]).default("coercion").describe("Which style to enforce: 'coercion' for implicit boolean checks like `if (arr.length)`, or 'explicit' for comparisons like `if (arr.length > 0)`.") },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression: (node, { options, sourceFile }) => {
+				if (options.style !== "coercion") return;
+				const { left, operatorToken, right } = node;
+				if (!ts$1.isPropertyAccessExpression(left) || !sizePropertyNames.has(left.name.text) || !ts$1.isNumericLiteral(right) || right.text !== "0") return;
+				const isNonZeroCheck = operatorToken.kind === ts$1.SyntaxKind.GreaterThanToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsToken;
+				const isZeroCheck = operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.LessThanEqualsToken;
+				if (!isNonZeroCheck && !isZeroCheck) return;
+				const propertyText = left.getText(sourceFile);
+				const needsBoolean = requiresBooleanType(node);
+				if (isZeroCheck) context.report({
+					data: { property: left.name.text },
+					fix: {
+						range: getTSNodeRange(node, sourceFile),
+						text: `!${propertyText}`
+					},
+					message: "coercionZeroCheck",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				else context.report({
+					data: { property: left.name.text },
+					fix: {
+						range: getTSNodeRange(node, sourceFile),
+						text: needsBoolean ? `!!${propertyText}` : propertyText
+					},
+					message: "coercionNonZeroCheck",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			PropertyAccessExpression: (node, { options, sourceFile }) => {
+				if (options.style !== "explicit") return;
+				if (!sizePropertyNames.has(node.name.text) || hasLogicalOrFallback(node) || isInNullishCoalescing(node)) return;
+				const { negated, outerNode } = isNegated(node);
+				if (!isInBooleanContext(outerNode)) return;
+				const propertyText = node.getText(sourceFile);
+				if (negated) context.report({
+					data: { property: node.name.text },
+					fix: {
+						range: getTSNodeRange(outerNode, sourceFile),
+						text: `${propertyText} === 0`
+					},
+					message: "explicitZeroCheck",
+					range: getTSNodeRange(outerNode, sourceFile)
+				});
+				else context.report({
+					data: { property: node.name.text },
+					fix: {
+						range: getTSNodeRange(outerNode, sourceFile),
+						text: `${propertyText} > 0`
+					},
+					message: "explicitNonZeroCheck",
+					range: getTSNodeRange(outerNode, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { sizeComparisonOperators_default as default };
+
+//# sourceMappingURL=sizeComparisonOperators.js.map

package/lib/rules/sparseArrays.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSparseArray", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noSparseArray", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=sparseArrays.d.ts.map

package/lib/rules/sparseArrays.js

@@ -1,54 +1,43 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports array literals with holes (sparse arrays).",
-        id: "sparseArrays",
-        preset: "logical",
-    },
-    messages: {
-        noSparseArray: {
-            primary: 'Sparse arrays with "holes" (empty slots) are misleading and behave differently from `undefined` values.',
-            secondary: [
-                "Array methods treat holes inconsistently, which can lead to unexpected behavior and bugs.",
-                "Using explicit `undefined` values makes the intent clear and ensures consistent behavior.",
-            ],
-            suggestions: [
-                "Replace holes with explicit `undefined` values.",
-                "Remove unintended commas if the holes are accidental.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                OmittedExpression: (node) => {
-                    const parent = node.parent;
-                    if (!ts.isArrayLiteralExpression(parent)) {
-                        return;
-                    }
-                    const syntaxList = parent
-                        .getChildren(context.sourceFile)
-                        .find((child) => child.kind === ts.SyntaxKind.SyntaxList);
-                    if (!syntaxList) {
-                        return;
-                    }
-                    const children = syntaxList.getChildren(context.sourceFile);
-                    const omittedIndex = children.indexOf(node);
-                    for (let i = omittedIndex + 1; i < children.length; i++) {
-                        if (children[i].kind === ts.SyntaxKind.CommaToken) {
-                            context.report({
-                                message: "noSparseArray",
-                                range: {
-                                    begin: children[i].getStart(context.sourceFile),
-                                    end: children[i].getEnd(),
-                                },
-                            });
-                            break;
-                        }
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/sparseArrays.ts
+var sparseArrays_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports array literals with holes (sparse arrays).",
+		id: "sparseArrays",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noSparseArray: {
+		primary: "Sparse arrays with \"holes\" (empty slots) are misleading and behave differently from `undefined` values.",
+		secondary: ["Array methods treat holes inconsistently, which can lead to unexpected behavior and bugs.", "Using explicit `undefined` values makes the intent clear and ensures consistent behavior."],
+		suggestions: ["Replace holes with explicit `undefined` values.", "Remove unintended commas if the holes are accidental."]
+	} },
+	setup(context) {
+		return { visitors: { OmittedExpression: (node, { sourceFile }) => {
+			if (node.parent.kind !== SyntaxKind.ArrayLiteralExpression) return;
+			const syntaxList = node.parent.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.SyntaxList);
+			if (!syntaxList) return;
+			const children = syntaxList.getChildren(sourceFile);
+			const omittedIndex = children.indexOf(node);
+			for (let i = omittedIndex + 1; i < children.length; i++) {
+				const child = nullThrows(children[i], "Child is expected to be present by the loop condition");
+				if (child.kind === SyntaxKind.CommaToken) {
+					context.report({
+						message: "noSparseArray",
+						range: {
+							begin: child.getStart(sourceFile),
+							end: child.getEnd()
+						}
+					});
+					break;
+				}
+			}
+		} } };
+	}
 });
+//#endregion
+export { sparseArrays_default as default };
+
+//# sourceMappingURL=sparseArrays.js.map

package/lib/rules/staticMemberOnlyClasses.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports classes that only contain static members.";
+    readonly id: "staticMemberOnlyClasses";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noStaticOnlyClass", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=staticMemberOnlyClasses.d.ts.map

package/lib/rules/staticMemberOnlyClasses.js

@@ -0,0 +1,77 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/staticMemberOnlyClasses.ts
+function hasDecorators(node) {
+	return node.modifiers?.some(ts.isDecorator) ?? false;
+}
+function hasExtendsClause(node) {
+	return node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? false;
+}
+function hasPrivateConstructor(node) {
+	return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+}
+function hasStaticModifier(modifiers) {
+	return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ?? false;
+}
+function isAbstractClass(node) {
+	return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
+}
+function isEmptyConstructor(member) {
+	return !member.body?.statements.length && !member.parameters.length;
+}
+var staticMemberOnlyClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports classes that only contain static members.",
+		id: "staticMemberOnlyClasses",
+		presets: ["logicalStrict"]
+	},
+	messages: { noStaticOnlyClass: {
+		primary: "This class only contains static members. Consider using module-level exports instead.",
+		secondary: ["Classes with only static members add unnecessary complexity.", "Module-level functions and constants are simpler and more idiomatic in JavaScript/TypeScript."],
+		suggestions: ["Use module-level functions and constants instead of a static-only class.", "If grouping is needed, use a plain object or namespace."]
+	} },
+	setup(context) {
+		function checkClass(node, { sourceFile }) {
+			if (hasExtendsClause(node) || isAbstractClass(node) || hasDecorators(node) || !node.members.length) return;
+			let hasNonStaticMember = false;
+			let hasPrivateConstructorMember = false;
+			for (const member of node.members) {
+				if (ts.isConstructorDeclaration(member)) {
+					if (hasPrivateConstructor(member)) {
+						hasPrivateConstructorMember = true;
+						break;
+					}
+					if (!isEmptyConstructor(member)) {
+						hasNonStaticMember = true;
+						break;
+					}
+					continue;
+				}
+				if (ts.isSemicolonClassElement(member) || ts.isClassStaticBlockDeclaration(member)) continue;
+				if (ts.isIndexSignatureDeclaration(member)) {
+					hasNonStaticMember = true;
+					break;
+				}
+				if ((ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) && !hasStaticModifier(member.modifiers)) {
+					hasNonStaticMember = true;
+					break;
+				}
+			}
+			if (hasPrivateConstructorMember || hasNonStaticMember) return;
+			const reportRange = getTSNodeRange(node.name ?? node, sourceFile);
+			context.report({
+				message: "noStaticOnlyClass",
+				range: reportRange
+			});
+		}
+		return { visitors: {
+			ClassDeclaration: checkClass,
+			ClassExpression: checkClass
+		} };
+	}
+});
+//#endregion
+export { staticMemberOnlyClasses_default as default };
+
+//# sourceMappingURL=staticMemberOnlyClasses.js.map

package/lib/rules/stringCaseMismatches.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports string case method calls compared against literals with mismatched casing.";
+    readonly id: "stringCaseMismatches";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "mismatch", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringCaseMismatches.d.ts.map

package/lib/rules/stringCaseMismatches.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/stringCaseMismatches.ts
+function isLowerCase(text) {
+	return text === text.toLowerCase();
+}
+function isStringLiteral$1(node) {
+	return ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node);
+}
+function isUpperCase(text) {
+	return text === text.toUpperCase();
+}
+var stringCaseMismatches_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports string case method calls compared against literals with mismatched casing.",
+		id: "stringCaseMismatches",
+		presets: ["logical"]
+	},
+	messages: { mismatch: {
+		primary: "This `{{ method }}()` call is compared against a string that is not {{ expectedCase }}.",
+		secondary: ["The comparison will always be {{ result }} because the casing doesn't match."],
+		suggestions: ["Change the compared string to {{ expectedCase }}: \"{{ corrected }}\"."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+			if (node.expression.name.text !== "toLowerCase" && node.expression.name.text !== "toUpperCase" || node.arguments.length || !ts$1.isBinaryExpression(node.parent)) return;
+			const operator = node.parent.operatorToken.kind;
+			if (operator !== ts$1.SyntaxKind.EqualsEqualsToken && operator !== ts$1.SyntaxKind.EqualsEqualsEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsEqualsToken) return;
+			const otherSide = node.parent.left === node ? node.parent.right : node.parent.left;
+			if (!isStringLiteral$1(otherSide)) return;
+			const value = otherSide.text;
+			const isToLower = node.expression.name.text === "toLowerCase";
+			const expectedCase = isToLower ? "lowercase" : "uppercase";
+			if (isToLower ? isLowerCase(value) : isUpperCase(value)) return;
+			const corrected = isToLower ? value.toLowerCase() : value.toUpperCase();
+			const isEquality = operator === ts$1.SyntaxKind.EqualsEqualsToken || operator === ts$1.SyntaxKind.EqualsEqualsEqualsToken;
+			context.report({
+				data: {
+					corrected,
+					expectedCase,
+					method: node.expression.name.text,
+					result: isEquality ? "false" : "true"
+				},
+				message: "mismatch",
+				range: {
+					begin: otherSide.getStart(sourceFile),
+					end: otherSide.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { stringCaseMismatches_default as default };
+
+//# sourceMappingURL=stringCaseMismatches.js.map