@flint.fyi/ts 0.15.0 → 0.18.1

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,7 +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").TypeScriptFileServices, "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,55 +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, { sourceFile }) => {
-                    const parent = node.parent;
-                    if (!ts.isArrayLiteralExpression(parent)) {
-                        return;
-                    }
-                    const syntaxList = parent
-                        .getChildren(sourceFile)
-                        .find((child) => child.kind === ts.SyntaxKind.SyntaxList);
-                    if (!syntaxList) {
-                        return;
-                    }
-                    const children = syntaxList.getChildren(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(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

package/lib/rules/stringCodePoints.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.";
+    readonly id: "stringCodePoints";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferCodePointAt" | "preferFromCodePoint", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringCodePoints.d.ts.map

package/lib/rules/stringCodePoints.js

@@ -0,0 +1,50 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/stringCodePoints.ts
+var stringCodePoints_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.",
+		id: "stringCodePoints",
+		presets: ["logical"]
+	},
+	messages: {
+		preferCodePointAt: {
+			primary: "Prefer `codePointAt` over `charCodeAt` for proper Unicode support.",
+			secondary: ["charCodeAt only handles characters in the Basic Multilingual Plane (BMP).", "codePointAt correctly handles all Unicode code points, including emoji."],
+			suggestions: ["Replace with codePointAt()."]
+		},
+		preferFromCodePoint: {
+			primary: "Prefer `String.fromCodePoint` over `String.fromCharCode` for proper Unicode support.",
+			secondary: ["fromCharCode only handles code points up to U+FFFF.", "fromCodePoint correctly handles all Unicode code points."],
+			suggestions: ["Replace with String.fromCodePoint()."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			CallExpression(node, { sourceFile, typeChecker }) {
+				if (ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "charCodeAt" && tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(node.expression.expression), ts$1.TypeFlags.StringLike)) context.report({
+					message: "preferCodePointAt",
+					range: {
+						begin: node.expression.name.getStart(sourceFile),
+						end: node.expression.name.getEnd()
+					}
+				});
+			},
+			PropertyAccessExpression(node, { sourceFile, typeChecker }) {
+				if (node.name.text === "fromCharCode" && ts$1.isIdentifier(node.expression) && isGlobalDeclarationOfName(node.expression, "String", typeChecker)) context.report({
+					message: "preferFromCodePoint",
+					range: {
+						begin: node.name.getStart(sourceFile),
+						end: node.name.getEnd()
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { stringCodePoints_default as default };
+
+//# sourceMappingURL=stringCodePoints.js.map

package/lib/rules/stringSliceMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports usage of `substring` instead of slice for string operations.";
+    readonly id: "stringSliceMethods";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferSliceOverSubstring", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringSliceMethods.d.ts.map

package/lib/rules/stringSliceMethods.js

@@ -0,0 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/stringSliceMethods.ts
+var stringSliceMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports usage of `substring` instead of slice for string operations.",
+		id: "stringSliceMethods",
+		presets: ["logical"]
+	},
+	messages: { preferSliceOverSubstring: {
+		primary: "Prefer `slice` over `substring` for more consistent behavior.",
+		secondary: [
+			"`slice` has predictable behavior matching `Array.prototype.slice`.",
+			"`substring` auto-swaps arguments if start > end, which can be confusing.",
+			"`substring` also treats negative indices as 0, unlike `slice`."
+		],
+		suggestions: ["Replace with slice()."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
+			if (ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "substring" && tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(node, typeChecker), ts$1.TypeFlags.StringLike)) {
+				const args = node.arguments.map((arg) => arg.getText(sourceFile));
+				const receiver = node.expression.expression.getText(sourceFile);
+				const replacement = !args.length ? `${receiver}.slice()` : args.length === 1 ? `${receiver}.slice(${args[0]})` : `${receiver}.slice(${args[0]}, ${args[1]})`;
+				context.report({
+					message: "preferSliceOverSubstring",
+					range: getTSNodeRange(node.expression.name, sourceFile),
+					suggestions: [{
+						id: "replaceWithSlice",
+						range: {
+							begin: node.getStart(sourceFile),
+							end: node.getEnd()
+						},
+						text: replacement
+					}]
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { stringSliceMethods_default as default };
+
+//# sourceMappingURL=stringSliceMethods.js.map

package/lib/rules/stringStartsEndsWith.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex patterns that can be replaced with `endsWith` or `startsWith`.";
+    readonly id: "stringStartsEndsWith";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferEndsWith" | "preferStartsWith", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringStartsEndsWith.d.ts.map

package/lib/rules/stringStartsEndsWith.js

@@ -0,0 +1,79 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/stringStartsEndsWith.ts
+const REGEX_METACHARACTERS = /[+[{(.?*|\\]/;
+function escapeString(str) {
+	return str.replace(/["'\\]/g, "\\$&");
+}
+function isSimpleString(pattern) {
+	return !REGEX_METACHARACTERS.test(pattern);
+}
+var stringStartsEndsWith_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex patterns that can be replaced with `endsWith` or `startsWith`.",
+		id: "stringStartsEndsWith",
+		presets: ["stylistic"]
+	},
+	messages: {
+		preferEndsWith: {
+			primary: "Prefer `endsWith()` over a regex with `$` for readability.",
+			secondary: ["`endsWith` is generally more readable than using a regular expression."],
+			suggestions: ["Replace the regular expression with `endsWith()`."]
+		},
+		preferStartsWith: {
+			primary: "Prefer `startsWith()` over a regex with `^` for readability.",
+			secondary: ["`startsWith` is generally more readable than using a regular expression."],
+			suggestions: ["Replace the regular expression with `startsWith()`."]
+		}
+	},
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+			if (node.expression.name.text !== "test") return;
+			const callee = node.expression.expression;
+			if (!ts$1.isRegularExpressionLiteral(callee)) return;
+			const regexText = callee.text;
+			const match = /^\/(.*)\/([gimsuy]*)$/.exec(regexText);
+			if (!match) return;
+			const pattern = match[1];
+			const flags = match[2];
+			if (flags.includes("i") || flags.includes("m")) return;
+			const argument = node.arguments[0];
+			if (!argument) return;
+			const argumentText = argument.getText(sourceFile);
+			const callRange = getTSNodeRange(node, sourceFile);
+			if (pattern.startsWith("^") && !pattern.endsWith("$")) {
+				const stringPart = pattern.slice(1);
+				if (isSimpleString(stringPart)) context.report({
+					fix: {
+						range: callRange,
+						text: `${argumentText}.startsWith("${escapeString(stringPart)}")`
+					},
+					message: "preferStartsWith",
+					range: {
+						begin: callee.getStart(sourceFile),
+						end: callee.getEnd()
+					}
+				});
+			} else if (pattern.endsWith("$") && !pattern.startsWith("^")) {
+				const stringPart = pattern.slice(0, -1);
+				if (isSimpleString(stringPart)) context.report({
+					fix: {
+						range: callRange,
+						text: `${argumentText}.endsWith("${escapeString(stringPart)}")`
+					},
+					message: "preferEndsWith",
+					range: {
+						begin: callee.getStart(sourceFile),
+						end: callee.getEnd()
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { stringStartsEndsWith_default as default };
+
+//# sourceMappingURL=stringStartsEndsWith.js.map

package/lib/rules/structuredCloneMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.";
+    readonly id: "structuredCloneMethods";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferStructuredClone", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=structuredCloneMethods.d.ts.map