@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/arrayFlatMethods.js

@@ -1,81 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { skipParentheses } from "./utils/skipParentheses.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayFlatMethods.ts
-function isConcatApply(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "apply") return false;
-	const callExpression = node.expression.expression;
-	if (!ts$1.isPropertyAccessExpression(callExpression) || callExpression.name.text !== "concat") return false;
-	const concatObject = callExpression.expression;
-	const isEmptyArrayConcat = isEmptyArrayLiteral(concatObject);
-	const isArrayPrototypeConcat = ts$1.isPropertyAccessExpression(concatObject) && ts$1.isIdentifier(concatObject.expression) && concatObject.expression.text === "Array" && concatObject.name.text === "prototype";
-	if (!isEmptyArrayConcat && !isArrayPrototypeConcat || node.arguments.length !== 2) return false;
-	const firstArg = node.arguments[0];
-	if (!isEmptyArrayLiteral(firstArg)) return false;
-	const secondArg = node.arguments[1];
-	if (!secondArg) return false;
-	return isArrayOrTupleTypeAtLocation(secondArg, typeChecker);
-}
-function isConcatCall(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "call") return false;
-	const callExpression = node.expression.expression;
-	if (!ts$1.isPropertyAccessExpression(callExpression) || callExpression.name.text !== "concat") return false;
-	const concatObject = callExpression.expression;
-	if (!ts$1.isPropertyAccessExpression(concatObject) || !ts$1.isIdentifier(concatObject.expression) || concatObject.expression.text !== "Array" || concatObject.name.text !== "prototype") return false;
-	if (node.arguments.length !== 2) return false;
-	const firstArg = node.arguments[0];
-	if (!isEmptyArrayLiteral(firstArg)) return false;
-	const secondArg = node.arguments[1];
-	if (!ts$1.isSpreadElement(secondArg)) return false;
-	return isArrayOrTupleTypeAtLocation(secondArg.expression, typeChecker);
-}
-function isConcatSpread(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "concat") return false;
-	const object = node.expression.expression;
-	if (!isEmptyArrayLiteral(object)) return false;
-	if (node.arguments.length !== 1) return false;
-	const arg = node.arguments[0];
-	if (!arg || !ts$1.isSpreadElement(arg)) return false;
-	return isArrayOrTupleTypeAtLocation(arg.expression, typeChecker);
-}
-function isEmptyArrayLiteral(node) {
-	return ts$1.isArrayLiteralExpression(node) && !node.elements.length;
-}
-function isIdentityArrowFunction(node) {
-	const expression = skipParentheses(node);
-	if (!ts$1.isArrowFunction(expression) || expression.parameters.length !== 1) return false;
-	const param = expression.parameters[0];
-	if (!ts$1.isIdentifier(param.name)) return false;
-	const body = skipParentheses(expression.body);
-	return body.kind === ts$1.SyntaxKind.Identifier && body.text === param.name.text;
-}
-function isIdentityFlatMapCall(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "flatMap" || node.arguments.length !== 1) return false;
-	const arg = node.arguments[0];
-	if (!isIdentityArrowFunction(arg)) return false;
-	return isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
-}
-var arrayFlatMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports legacy techniques to flatten arrays instead of using `.flat()`.",
-		id: "arrayFlatMethods",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferFlat: {
-		primary: "Prefer `.flat()` over legacy array flattening techniques.",
-		secondary: ["ES2019 introduced `Array.prototype.flat()` as the standard way to flatten arrays.", "Using modern array methods improves code readability and consistency."],
-		suggestions: ["Replace this with `.flat()`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (isIdentityFlatMapCall(node, typeChecker) || isConcatSpread(node, typeChecker) || isConcatApply(node, typeChecker) || isConcatCall(node, typeChecker)) context.report({
-				message: "preferFlat",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayFlatMethods_default as default };

package/lib/rules/arrayFlatUnnecessaryDepths.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `1` as the depth argument of `.flat()` since it is the default.";
-    readonly id: "arrayFlatUnnecessaryDepths";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryDepth", undefined>;
-export default _default;

package/lib/rules/arrayFlatUnnecessaryDepths.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { getStaticNumberValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayFlatUnnecessaryDepths.ts
-var arrayFlatUnnecessaryDepths_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `1` as the depth argument of `.flat()` since it is the default.",
-		id: "arrayFlatUnnecessaryDepths",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryDepth: {
-		primary: "Unnecessary depth argument of `1` in `.flat()` call.",
-		secondary: ["The default depth for `.flat()` is `1`, so passing it explicitly is redundant."],
-		suggestions: ["Remove the depth argument."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "flat" || node.arguments.length !== 1) return;
-			const arg = node.arguments[0];
-			if (getStaticNumberValue(arg) !== 1) return;
-			if (!isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
-			context.report({
-				message: "unnecessaryDepth",
-				range: getTSNodeRange(arg, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayFlatUnnecessaryDepths_default as default };

package/lib/rules/arrayIncludes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.";
-    readonly id: "arrayIncludes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferIncludes", undefined>;
-export default _default;

package/lib/rules/arrayIncludes.js

@@ -1,51 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { getStaticNumberValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayIncludes.ts
-function hasIncludesMethod(node, typeChecker) {
-	const includesProperty = getConstrainedTypeAtLocation(node, typeChecker).getProperty("includes");
-	return includesProperty && !!typeChecker.getTypeOfSymbol(includesProperty).getCallSignatures().length;
-}
-function isIndexOfCall(node) {
-	return ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "indexOf";
-}
-function isIndexOfComparison(node, typeChecker) {
-	const { left, operatorToken, right } = node;
-	let indexOfAndValue;
-	if (ts$1.isCallExpression(left) && isIndexOfCall(left)) indexOfAndValue = [left, right];
-	else if (ts$1.isCallExpression(right) && isIndexOfCall(right)) indexOfAndValue = [right, left];
-	if (!indexOfAndValue) return;
-	const [indexOfCall, comparedValue] = indexOfAndValue;
-	if (!ts$1.isPropertyAccessExpression(indexOfCall.expression) || !hasIncludesMethod(indexOfCall.expression.expression, typeChecker)) return;
-	const kind = operatorToken.kind;
-	const comparedNumber = getStaticNumberValue(comparedValue);
-	const indexOfOnLeft = ts$1.isCallExpression(left);
-	return (comparedNumber === -1 && (kind === ts$1.SyntaxKind.ExclamationEqualsToken || kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken || kind === ts$1.SyntaxKind.EqualsEqualsToken || kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || indexOfOnLeft && kind === ts$1.SyntaxKind.GreaterThanToken || !indexOfOnLeft && kind === ts$1.SyntaxKind.LessThanToken) || comparedNumber === 0 && (indexOfOnLeft && kind === ts$1.SyntaxKind.GreaterThanEqualsToken || !indexOfOnLeft && kind === ts$1.SyntaxKind.LessThanEqualsToken)) && {
-		indexOfCall,
-		node
-	};
-}
-var arrayIncludes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.",
-		id: "arrayIncludes",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferIncludes: {
-		primary: "Prefer the cleaner `.includes()` over `.indexOf()` with a binary comparison.",
-		secondary: ["Using `.includes()` is more readable and expressive than comparing `.indexOf()` against `-1` or `0`.", "ES2015 added `String.prototype.includes()` and ES2016 added `Array.prototype.includes()` for this purpose."],
-		suggestions: ["Replace the `.indexOf()` comparison with `.includes()`."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
-			const result = isIndexOfComparison(node, typeChecker);
-			if (result) context.report({
-				message: "preferIncludes",
-				range: getTSNodeRange(result.node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayIncludes_default as default };

package/lib/rules/arrayIncludesMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.";
-    readonly id: "arrayIncludesMethods";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferIncludes", undefined>;
-export default _default;

package/lib/rules/arrayIncludesMethods.js

@@ -1,35 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { isDirectEqualityCheck } from "./utils/isDirectEqualityCheck.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayIncludesMethods.ts
-function isSomeWithDirectEquality(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "some" || node.arguments.length !== 1) return false;
-	const callback = node.arguments[0];
-	if (!ts$1.isArrowFunction(callback) && !ts$1.isFunctionExpression(callback) || callback.parameters.length !== 1) return false;
-	const firstParameter = callback.parameters[0];
-	return firstParameter.name.kind === ts$1.SyntaxKind.Identifier && isDirectEqualityCheck(callback, [ts$1.SyntaxKind.EqualsEqualsToken, ts$1.SyntaxKind.EqualsEqualsEqualsToken], firstParameter.name.text) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
-}
-var arrayIncludesMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.",
-		id: "arrayIncludesMethods",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferIncludes: {
-		primary: "Prefer `.includes()` over `.some()` with a simple equality check.",
-		secondary: ["`Array.prototype.some()` is intended for more complex predicate checks.", "For simple equality checks, `.includes()` is more readable and expressive."],
-		suggestions: ["Replace `.some(x => x === value)` with `.includes(value)`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (isSomeWithDirectEquality(node, typeChecker)) context.report({
-				message: "preferIncludes",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayIncludesMethods_default as default };

package/lib/rules/arrayIndexOfMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.";
-    readonly id: "arrayIndexOfMethods";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferIndexOf" | "preferLastIndexOf", undefined>;
-export default _default;

package/lib/rules/arrayIndexOfMethods.js

@@ -1,49 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { isDirectEqualityCheck } from "./utils/isDirectEqualityCheck.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayIndexOfMethods.ts
-function isFindIndexWithDirectEquality(node, typeChecker) {
-	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-	const methodName = node.expression.name.text;
-	if (methodName !== "findIndex" && methodName !== "findLastIndex" || node.arguments.length !== 1) return;
-	const callback = node.arguments[0];
-	if (!ts$1.isArrowFunction(callback) && !ts$1.isFunctionExpression(callback) || callback.parameters.length !== 1) return;
-	const firstParameter = callback.parameters[0];
-	if (firstParameter.name.kind !== ts$1.SyntaxKind.Identifier || !isDirectEqualityCheck(callback, [ts$1.SyntaxKind.EqualsEqualsEqualsToken], firstParameter.name.text) || !isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
-	return {
-		methodName,
-		node
-	};
-}
-var arrayIndexOfMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.",
-		id: "arrayIndexOfMethods",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferIndexOf: {
-			primary: "Prefer `.indexOf()` over `.findIndex()` with a simple equality check.",
-			secondary: ["`.findIndex()` is intended for more complex predicate checks.", "For simple equality checks, `.indexOf()` is more readable."],
-			suggestions: ["Replace `.findIndex(x => x === value)` with `.indexOf(value)`."]
-		},
-		preferLastIndexOf: {
-			primary: "Prefer `.lastIndexOf()` over `.findLastIndex()` with a simple equality check.",
-			secondary: ["`.findLastIndex()` is intended for more complex predicate checks.", "For simple equality checks, `.lastIndexOf()` is more readable."],
-			suggestions: ["Replace `.findLastIndex(x => x === value)` with `.lastIndexOf(value)`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			const result = isFindIndexWithDirectEquality(node, typeChecker);
-			if (result) context.report({
-				message: result.methodName === "findIndex" ? "preferIndexOf" : "preferLastIndexOf",
-				range: getTSNodeRange(result.node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayIndexOfMethods_default as default };

package/lib/rules/arrayLoops.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.forEach()` when a for-of loop can be used.";
-    readonly id: "arrayLoops";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferForOf", undefined>;
-export default _default;

package/lib/rules/arrayLoops.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayLoops.ts
-function isForEachCall(node) {
-	return node.expression.kind === ts$1.SyntaxKind.PropertyAccessExpression && node.expression.name.text === "forEach" && node.arguments.length >= 1;
-}
-var arrayLoops_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.forEach()` when a for-of loop can be used.",
-		id: "arrayLoops",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferForOf: {
-		primary: "Prefer a more direct for-of loop over `.forEach()`.",
-		secondary: [
-			"for-of loops are often more readable and offer benefits over `.forEach()`.",
-			"for-of allows using `break` to exit early, `continue` to skip iterations, and `return` to exit the containing function.",
-			"TypeScript type narrowing works better inside for-of loops since no function boundary is crossed."
-		],
-		suggestions: ["Replace `.forEach(callback)` with a for-of loop."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (isForEachCall(node) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) context.report({
-				message: "preferForOf",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayLoops_default as default };

package/lib/rules/arrayMapIdentities.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.flatMap()` with an identity function that returns its argument unchanged.";
-    readonly id: "arrayMapIdentities";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "identityFlatMap", undefined>;
-export default _default;

package/lib/rules/arrayMapIdentities.js

@@ -1,72 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayMapIdentities.ts
-var arrayMapIdentities_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.flatMap()` with an identity function that returns its argument unchanged.",
-		id: "arrayMapIdentities",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { identityFlatMap: {
-		primary: "Prefer `.flat()` over `.flatMap()` when the callback returns its argument unchanged.",
-		secondary: ["Using an identity function with `.flatMap()` is equivalent to calling `.flat()`.", "Using `.flat()` is more concise and expresses intent more clearly."],
-		suggestions: ["Replace `.flatMap(...)` with `.flat()`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "flatMap" || node.arguments.length !== 1) return;
-			const callback = node.arguments[0];
-			if (!isIdentityFunction(callback)) return;
-			const objectText = node.expression.expression.getText(sourceFile);
-			context.report({
-				fix: {
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					},
-					text: `${objectText}.flat()`
-				},
-				message: "identityFlatMap",
-				range: {
-					begin: node.expression.name.getStart(sourceFile) - 1,
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function blockReturnsIdentifier(block, parameterName) {
-	if (block.statements.length !== 1) return false;
-	const statement = block.statements[0];
-	if (!ts$1.isReturnStatement(statement) || !statement.expression) return false;
-	return expressionMatchesName(statement.expression, parameterName);
-}
-function expressionMatchesName(expression, name) {
-	const unwrapped = ts$1.isParenthesizedExpression(expression) ? expression.expression : expression;
-	return ts$1.isIdentifier(unwrapped) && unwrapped.text === name;
-}
-function getSingleParameterName(parameters) {
-	if (parameters.length !== 1) return;
-	const parameter = parameters[0];
-	if (!ts$1.isIdentifier(parameter.name)) return;
-	return parameter.name.text;
-}
-function isIdentityArrowFunction(node) {
-	const parameterName = getSingleParameterName(node.parameters);
-	if (!parameterName) return false;
-	if (ts$1.isBlock(node.body)) return blockReturnsIdentifier(node.body, parameterName);
-	return expressionMatchesName(node.body, parameterName);
-}
-function isIdentityFunction(node) {
-	if (ts$1.isArrowFunction(node)) return isIdentityArrowFunction(node);
-	if (ts$1.isFunctionExpression(node)) return isIdentityFunctionExpression(node);
-	return false;
-}
-function isIdentityFunctionExpression(node) {
-	const parameterName = getSingleParameterName(node.parameters);
-	if (!parameterName) return false;
-	return blockReturnsIdentifier(node.body, parameterName);
-}
-//#endregion
-export { arrayMapIdentities_default as default };

package/lib/rules/arrayMutableReverses.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `.reverse()` calls on arrays that mutate the original array.";
-    readonly id: "arrayMutableReverses";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferToReversed", undefined>;
-export default _default;

package/lib/rules/arrayMutableReverses.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isBuiltinArrayMethod, isInlineArrayCreation, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/arrayMutableReverses.ts
-var arrayMutableReverses_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `.reverse()` calls on arrays that mutate the original array.",
-		id: "arrayMutableReverses",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferToReversed: {
-		primary: "Use `.toReversed()` instead of `.reverse()` to avoid mutating the original array.",
-		secondary: ["The `.reverse()` method mutates the array in place.", "The `.toReversed()` method returns a new reversed array without modifying the original."],
-		suggestions: ["Replace `.reverse()` with `.toReversed()`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isBuiltinArrayMethod("reverse", node, typeChecker) || isInlineArrayCreation(node.expression.expression)) return;
-			const arrayText = node.expression.expression.getText(sourceFile);
-			context.report({
-				fix: {
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					},
-					text: `${arrayText}.toReversed()`
-				},
-				message: "preferToReversed",
-				range: {
-					begin: node.expression.name.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayMutableReverses_default as default };

package/lib/rules/arrayMutableSorts.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `.sort()` calls on arrays that mutate the original array.";
-    readonly id: "arrayMutableSorts";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferToSorted", undefined>;
-export default _default;

package/lib/rules/arrayMutableSorts.js

@@ -1,70 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isBuiltinArrayMethod, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayMutableSorts.ts
-const methodsReturningNewArray = /* @__PURE__ */ new Set([
-	"concat",
-	"entries",
-	"filter",
-	"flat",
-	"flatMap",
-	"from",
-	"keys",
-	"map",
-	"of",
-	"slice",
-	"split",
-	"values"
-]);
-const objectStaticMethods = /* @__PURE__ */ new Set([
-	"entries",
-	"keys",
-	"values"
-]);
-function isInlineArrayCreation$1(node) {
-	if (ts$1.isArrayLiteralExpression(node)) return true;
-	if (ts$1.isParenthesizedExpression(node)) return isInlineArrayCreation$1(node.expression);
-	if (ts$1.isCallExpression(node)) {
-		if (ts$1.isPropertyAccessExpression(node.expression)) {
-			const methodName = node.expression.name.text;
-			if (ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && objectStaticMethods.has(methodName)) return true;
-			if (ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Array" && (methodName === "from" || methodName === "of")) return true;
-			if (methodsReturningNewArray.has(methodName)) return true;
-		}
-		if (ts$1.isIdentifier(node.expression) && node.expression.text === "Array" && ts$1.isNewExpression(node.parent)) return true;
-	}
-	if (ts$1.isNewExpression(node) && ts$1.isIdentifier(node.expression) && node.expression.text === "Array") return true;
-	return false;
-}
-var arrayMutableSorts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `.sort()` calls on arrays that mutate the original array.",
-		id: "arrayMutableSorts",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferToSorted: {
-		primary: "Use `.toSorted()` instead of `.sort()` to avoid mutating the original array.",
-		secondary: ["The `.sort()` method mutates the array in place.", "The `.toSorted()` method returns a new sorted array without modifying the original."],
-		suggestions: ["Replace `.sort()` with `.toSorted()`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isBuiltinArrayMethod("sort", node, typeChecker) || isInlineArrayCreation$1(node.expression.expression)) return;
-			const arrayText = node.expression.expression.getText(sourceFile);
-			const argumentsText = node.arguments.length ? node.arguments.map((arg) => arg.getText(sourceFile)).join(", ") : "";
-			context.report({
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: `${arrayText}.toSorted(${argumentsText})`
-				},
-				message: "preferToSorted",
-				range: {
-					begin: node.expression.name.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayMutableSorts_default as default };

package/lib/rules/arrayReduceTypeArguments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `Array#reduce` calls using type assertions on initial values instead of type arguments.";
-    readonly id: "arrayReduceTypeArguments";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferTypeParameter", undefined>;
-export default _default;

package/lib/rules/arrayReduceTypeArguments.js

@@ -1,62 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/arrayReduceTypeArguments.ts
-function isTypeAssertion(node) {
-	return node.kind === ts.SyntaxKind.AsExpression || node.kind === ts.SyntaxKind.TypeAssertionExpression;
-}
-var arrayReduceTypeArguments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `Array#reduce` calls using type assertions on initial values instead of type arguments.",
-		id: "arrayReduceTypeArguments",
-		presets: ["logicalStrict"]
-	},
-	messages: { preferTypeParameter: {
-		primary: "Using a type assertion on a reducer's initial value is less type-safe than providing a type parameter.",
-		secondary: ["Using `Array#reduce<T>` with a type parameter is clearer than asserting the initial value type.", "This avoids unnecessary type assertions and keeps generic inference consistent."],
-		suggestions: ["Replace the type assertion with a type parameter on `reduce`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression) && !ts.isElementAccessExpression(node.expression)) return;
-			if ((ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : ts.isStringLiteral(node.expression.argumentExpression) ? node.expression.argumentExpression.text : void 0) !== "reduce" || node.arguments.length < 2) return;
-			const secondArg = node.arguments[1];
-			if (!isTypeAssertion(secondArg)) return;
-			if (!isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
-			const initializerType = typeChecker.getTypeAtLocation(secondArg.expression);
-			const assertedType = typeChecker.getTypeAtLocation(secondArg.type);
-			if (!typeChecker.isTypeAssignableTo(initializerType, assertedType)) return;
-			const typeAnnotationText = secondArg.type.getText(sourceFile);
-			const fixes = [];
-			if (!node.typeArguments) fixes.push({
-				range: {
-					begin: node.expression.getEnd(),
-					end: node.expression.getEnd()
-				},
-				text: `<${typeAnnotationText}>`
-			});
-			if (secondArg.kind === ts.SyntaxKind.AsExpression) fixes.push({
-				range: {
-					begin: secondArg.expression.getEnd(),
-					end: secondArg.getEnd()
-				},
-				text: ""
-			});
-			else fixes.push({
-				range: {
-					begin: secondArg.getStart(sourceFile),
-					end: secondArg.expression.getStart(sourceFile)
-				},
-				text: ""
-			});
-			context.report({
-				fix: fixes,
-				message: "preferTypeParameter",
-				range: getTSNodeRange(secondArg, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayReduceTypeArguments_default as default };

package/lib/rules/arraySliceUnnecessaryEnd.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.";
-    readonly id: "arraySliceUnnecessaryEnd";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryEnd", undefined>;
-export default _default;