@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/singleVariableDeclarations.js

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

@@ -1,16 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "coercionNonZeroCheck" | "coercionZeroCheck" | "explicitNonZeroCheck" | "explicitZeroCheck", {
-    style: z.ZodDefault<z.ZodEnum<{
-        coercion: "coercion";
-        explicit: "explicit";
-    }>>;
-}>;
-export default _default;
-//# sourceMappingURL=sizeComparisonOperators.d.ts.map

package/lib/rules/sizeComparisonOperators.js

@@ -1,148 +0,0 @@
-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,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports array literals with holes (sparse arrays).";
-    readonly id: "sparseArrays";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noSparseArray", undefined>;
-export default _default;
-//# sourceMappingURL=sparseArrays.d.ts.map

package/lib/rules/sparseArrays.js

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

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

package/lib/rules/staticMemberOnlyClasses.js

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

@@ -1,10 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "mismatch", undefined>;
-export default _default;
-//# sourceMappingURL=stringCaseMismatches.d.ts.map

package/lib/rules/stringCaseMismatches.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/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

@@ -1,10 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferCodePointAt" | "preferFromCodePoint", undefined>;
-export default _default;
-//# sourceMappingURL=stringCodePoints.d.ts.map

package/lib/rules/stringCodePoints.js

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

@@ -1,10 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSliceOverSubstring", undefined>;
-export default _default;
-//# sourceMappingURL=stringSliceMethods.d.ts.map

package/lib/rules/stringSliceMethods.js

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

@@ -1,10 +0,0 @@
-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: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferEndsWith" | "preferStartsWith", undefined>;
-export default _default;
-//# sourceMappingURL=stringStartsEndsWith.d.ts.map

package/lib/rules/stringStartsEndsWith.js

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

@@ -1,10 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferStructuredClone", undefined>;
-export default _default;
-//# sourceMappingURL=structuredCloneMethods.d.ts.map