@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/arrayCallbackReturns.js

@@ -1,73 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/arrayCallbackReturns.ts
-const arrayMethodsRequiringReturn = new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flatMap",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some",
-	"sort",
-	"toSorted"
-]);
-var arrayCallbackReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports missing return statements in callbacks of array methods.",
-		id: "arrayCallbackReturns",
-		presets: ["javascript"]
-	},
-	messages: { missingReturn: {
-		primary: "Array method `{{ method }}` callback expects a return value.",
-		secondary: ["Array methods like `map`, `filter`, `find`, and `reduce` rely on return values from their callbacks.", "A missing return statement is often a mistake that causes the array method to produce unexpected results."],
-		suggestions: ["Add a return statement to the callback function.", "If you don't need the return value, consider using `forEach` instead."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			const methodName = node.expression.name.text;
-			if (!arrayMethodsRequiringReturn.has(methodName)) return;
-			const callback = node.arguments[0];
-			if (!callback) return;
-			const body = getCallbackBody(callback);
-			if (!body) return;
-			if (!hasReturnWithValue(body)) context.report({
-				data: { method: methodName },
-				message: "missingReturn",
-				range: {
-					begin: callback.getStart(sourceFile),
-					end: callback.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function getCallbackBody(node) {
-	if (ts$1.isArrowFunction(node)) return ts$1.isBlock(node.body) ? node.body : void 0;
-	if (ts$1.isFunctionExpression(node)) return node.body;
-}
-function hasReturnWithValue(block) {
-	let hasReturn = false;
-	function visit(node) {
-		if (hasReturn) return;
-		if (ts$1.isReturnStatement(node) && node.expression) {
-			hasReturn = true;
-			return;
-		}
-		if (tsutils.isFunctionScopeBoundary(node)) return;
-		ts$1.forEachChild(node, visit);
-	}
-	ts$1.forEachChild(block, visit);
-	return hasReturn;
-}
-//#endregion
-export { arrayCallbackReturns_default as default };
-
-//# sourceMappingURL=arrayCallbackReturns.js.map

package/lib/rules/arrayConstructors.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the `Array` constructor to create arrays instead of array literal syntax.";
-    readonly id: "arrayConstructors";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLiteral", undefined>;
-export default _default;
-//# sourceMappingURL=arrayConstructors.d.ts.map

package/lib/rules/arrayConstructors.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayConstructors.ts
-var arrayConstructors_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the `Array` constructor to create arrays instead of array literal syntax.",
-		id: "arrayConstructors",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferLiteral: {
-		primary: "Prefer array literal syntax over the `Array` constructor.",
-		secondary: ["The `Array` constructor has confusing behavior with a single numeric argument, creating a sparse array instead of an array containing that number.", "Array literal syntax is clearer and avoids potential pitfalls."],
-		suggestions: ["Use array literal syntax like `[]` or `[1, 2, 3]`."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			if (!ts$1.isIdentifier(node.expression) || node.expression.text !== "Array" || shouldAllowCallOrNew(node) || !isGlobalDeclarationOfName(node.expression, "Array", typeChecker)) return;
-			const argumentsText = node.arguments?.map((arg) => arg.getText(sourceFile)).join(", ");
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: `[${argumentsText}]`
-				},
-				message: "preferLiteral",
-				range
-			});
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-function getSoleArgument(node) {
-	return node.arguments?.length === 1 ? node.arguments[0] : void 0;
-}
-function shouldAllowCallOrNew(node) {
-	if (node.typeArguments && !!node.typeArguments.length) return true;
-	const soleArgument = getSoleArgument(node);
-	return !!soleArgument && ts$1.isNumericLiteral(soleArgument);
-}
-//#endregion
-export { arrayConstructors_default as default };
-
-//# sourceMappingURL=arrayConstructors.js.map

package/lib/rules/arrayDeleteUnnecessaryCounts.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.";
-    readonly id: "arrayDeleteUnnecessaryCounts";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryCount", undefined>;
-export default _default;
-//# sourceMappingURL=arrayDeleteUnnecessaryCounts.d.ts.map

package/lib/rules/arrayDeleteUnnecessaryCounts.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayDeleteUnnecessaryCounts.ts
-function isUnnecessaryCountArgument(argumentRoot, calleeObject, sourceFile) {
-	const argument = unwrapParenthesizedNode(argumentRoot);
-	switch (argument.kind) {
-		case ts$1.SyntaxKind.Identifier: return argument.text === "Infinity" ? "`Infinity`" : void 0;
-		case ts$1.SyntaxKind.PropertyAccessExpression:
-			if (ts$1.isIdentifier(argument.expression) && argument.expression.text === "Number" && ts$1.isIdentifier(argument.name) && argument.name.text === "POSITIVE_INFINITY") return "`Number.POSITIVE_INFINITY`";
-			if (ts$1.isIdentifier(argument.name) && argument.name.text === "length" && hasSameTokens(argument.expression, calleeObject, sourceFile)) return `\`${ts$1.isIdentifier(calleeObject) ? calleeObject.text : "…"}${argument.questionDotToken ? "?." : "."}length\``;
-	}
-}
-var arrayDeleteUnnecessaryCounts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.",
-		id: "arrayDeleteUnnecessaryCounts",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryCount: {
-		primary: "Passing {{ description }} as the {{ argumentName }} argument is unnecessary.",
-		secondary: ["When calling `splice` or `toSpliced`, omitting the second argument will delete or skip all elements after the start index.", "Using `.length` or `Infinity` is redundant and makes the code less clear."],
-		suggestions: ["Omit the second argument to achieve the same result."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression) || !ts$1.isIdentifier(node.expression.name)) return;
-			const methodName = node.expression.name.text;
-			if (methodName !== "splice" && methodName !== "toSpliced") return;
-			if (!typeChecker.isArrayType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker))) return;
-			if (node.arguments.length !== 2) return;
-			const firstArg = node.arguments[0];
-			if (ts$1.isSpreadElement(firstArg)) return;
-			const secondArg = node.arguments[1];
-			if (ts$1.isSpreadElement(secondArg)) return;
-			const description = isUnnecessaryCountArgument(secondArg, node.expression.expression, sourceFile);
-			if (!description) return;
-			const argumentName = methodName === "splice" ? "`deleteCount`" : "`skipCount`";
-			context.report({
-				data: {
-					argumentName,
-					description
-				},
-				message: "unnecessaryCount",
-				range: getTSNodeRange(secondArg, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayDeleteUnnecessaryCounts_default as default };
-
-//# sourceMappingURL=arrayDeleteUnnecessaryCounts.js.map

package/lib/rules/arrayElementDeletions.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the `delete` operator on array values.";
-    readonly id: "arrayElementDeletions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noArrayDelete", undefined>;
-export default _default;
-//# sourceMappingURL=arrayElementDeletions.d.ts.map

package/lib/rules/arrayElementDeletions.js

@@ -1,43 +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/arrayElementDeletions.ts
-function buildSpliceReplacement(node, elementAccess, sourceFile) {
-	const children = elementAccess.getChildren(sourceFile);
-	const openBracket = children.find((child) => child.kind === ts$1.SyntaxKind.OpenBracketToken);
-	const closeBracket = children.find((child) => child.kind === ts$1.SyntaxKind.CloseBracketToken);
-	return `${sourceFile.text.slice(node.getStart(sourceFile) + 6, openBracket?.getStart(sourceFile) ?? elementAccess.expression.getEnd())}.splice(${sourceFile.text.slice(openBracket?.getEnd() ?? elementAccess.argumentExpression.getStart(sourceFile), closeBracket?.getStart(sourceFile) ?? elementAccess.argumentExpression.getEnd())}, 1)`;
-}
-var arrayElementDeletions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the `delete` operator on array values.",
-		id: "arrayElementDeletions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noArrayDelete: {
-		primary: "Avoid using the `delete` operator on arrays.",
-		secondary: ["Using `delete` on an array element removes it but leaves an empty slot, which can lead to unexpected behavior.", "The array's `length` property is not affected, and the element becomes `undefined` with a hole in the array."],
-		suggestions: ["Use `Array#splice()` to remove elements."]
-	} },
-	setup(context) {
-		return { visitors: { DeleteExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isElementAccessExpression(node.expression) || !isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			const spliceText = buildSpliceReplacement(node, node.expression, sourceFile);
-			context.report({
-				message: "noArrayDelete",
-				range,
-				suggestions: [{
-					id: "useSplice",
-					range,
-					text: spliceText
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayElementDeletions_default as default };
-
-//# sourceMappingURL=arrayElementDeletions.js.map

package/lib/rules/arrayEmptyCallbackSlots.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports array methods with callbacks that will never be invoked on arrays with empty slots.";
-    readonly id: "arrayEmptyCallbackSlots";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "neverInvoked", undefined>;
-export default _default;
-//# sourceMappingURL=arrayEmptyCallbackSlots.d.ts.map

package/lib/rules/arrayEmptyCallbackSlots.js

@@ -1,45 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayEmptyCallbackSlots.ts
-function hasCallbackArgument(callExpression) {
-	if (!callExpression.arguments.length) return false;
-	const firstArgument = callExpression.arguments[0];
-	return ts$1.isArrowFunction(firstArgument) || ts$1.isFunctionExpression(firstArgument) || ts$1.isIdentifier(firstArgument) && firstArgument.text !== "undefined";
-}
-function isNumericLiteral$1(node) {
-	if (ts$1.isNumericLiteral(node)) return true;
-	if (ts$1.isPrefixUnaryExpression(node)) return (node.operator === ts$1.SyntaxKind.MinusToken || node.operator === ts$1.SyntaxKind.PlusToken) && ts$1.isNumericLiteral(node.operand);
-	return false;
-}
-var arrayEmptyCallbackSlots_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports array methods with callbacks that will never be invoked on arrays with empty slots.",
-		id: "arrayEmptyCallbackSlots",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { neverInvoked: {
-		primary: "This callback will not be invoked.",
-		secondary: ["When the Array constructor is called with a single number argument, it creates an array with empty slots (not actual undefined values).", "Callback methods like `map`, `filter`, `forEach`, etc. skip empty slots, so the callback will never run."],
-		suggestions: ["Use `Array.from({ length: n }, callback)` instead.", "Use `new Array(n).fill(undefined).map(callback)` to fill slots first."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			const objectExpression = node.expression.expression;
-			if (!ts$1.isNewExpression(objectExpression) || !ts$1.isIdentifier(objectExpression.expression) || !isGlobalDeclarationOfName(objectExpression.expression, "Array", typeChecker)) return;
-			const args = objectExpression.arguments;
-			if (args?.length !== 1) return;
-			const firstArgument = args[0];
-			if (!isNumericLiteral$1(firstArgument) || !hasCallbackArgument(node)) return;
-			context.report({
-				message: "neverInvoked",
-				range: getTSNodeRange(node.expression.name, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayEmptyCallbackSlots_default as default };
-
-//# sourceMappingURL=arrayEmptyCallbackSlots.js.map

package/lib/rules/arrayExistenceChecksConsistency.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports inconsistent styles for checking element existence using index methods.";
-    readonly id: "arrayExistenceChecksConsistency";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferEqualsMinusOne" | "preferNotEqualsMinusOne", undefined>;
-export default _default;
-//# sourceMappingURL=arrayExistenceChecksConsistency.d.ts.map

package/lib/rules/arrayExistenceChecksConsistency.js

@@ -1,86 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayExistenceChecksConsistency.ts
-const indexMethods = new Set([
-	"findIndex",
-	"findLastIndex",
-	"indexOf",
-	"lastIndexOf"
-]);
-var arrayExistenceChecksConsistency_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports inconsistent styles for checking element existence using index methods.",
-		id: "arrayExistenceChecksConsistency",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferEqualsMinusOne: {
-			primary: "Prefer `{{ replacement }}` over `{{ original }}` to check for non-existence.",
-			secondary: ["Using `=== -1` is clearer and more consistent than `< 0`.", "Index methods return -1 when an element is not found, so checking against -1 is more explicit."],
-			suggestions: ["Replace with `{{ replacement }}`."]
-		},
-		preferNotEqualsMinusOne: {
-			primary: "Prefer `{{ replacement }}` over `{{ original }}` to check for existence.",
-			secondary: ["Using `!== -1` is clearer and more consistent than `>= 0` or `> -1`.", "Index methods return -1 when an element is not found, so checking against -1 is more explicit."],
-			suggestions: ["Replace with `{{ replacement }}`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!isComparisonOperator(node.operatorToken.kind) || !isIndexMethodCall(node.left)) return;
-			const numberValue = getNumericLiteralValue(node.right);
-			if (numberValue === void 0) return;
-			const issue = detectIssue(node.operatorToken.kind, numberValue);
-			if (!issue) return;
-			const indexCallText = node.left.getText(sourceFile);
-			const original = `${indexCallText} ${getOperatorText(node.operatorToken.kind)} ${numberValue}`;
-			const replacement = `${indexCallText} ${issue[1]} -1`;
-			context.report({
-				data: {
-					original,
-					replacement
-				},
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: replacement
-				},
-				message: issue[0],
-				range: {
-					begin: node.operatorToken.getStart(sourceFile),
-					end: node.right.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function detectIssue(operator, value) {
-	switch (operator) {
-		case ts$1.SyntaxKind.GreaterThanEqualsToken: return value === 0 && ["preferNotEqualsMinusOne", "!=="];
-		case ts$1.SyntaxKind.GreaterThanToken: return value === -1 && ["preferNotEqualsMinusOne", "!=="];
-		case ts$1.SyntaxKind.LessThanToken: return value === 0 && ["preferEqualsMinusOne", "==="];
-	}
-}
-function getNumericLiteralValue(node) {
-	if (ts$1.isNumericLiteral(node)) return Number(node.text);
-	if (ts$1.isPrefixUnaryExpression(node) && node.operator === ts$1.SyntaxKind.MinusToken && ts$1.isNumericLiteral(node.operand)) return -Number(node.operand.text);
-}
-function getOperatorText(kind) {
-	switch (kind) {
-		case ts$1.SyntaxKind.GreaterThanEqualsToken: return ">=";
-		case ts$1.SyntaxKind.GreaterThanToken: return ">";
-		case ts$1.SyntaxKind.LessThanEqualsToken: return "<=";
-		case ts$1.SyntaxKind.LessThanToken: return "<";
-		default: return "";
-	}
-}
-function isComparisonOperator(kind) {
-	return kind === ts$1.SyntaxKind.LessThanToken || kind === ts$1.SyntaxKind.LessThanEqualsToken || kind === ts$1.SyntaxKind.GreaterThanToken || kind === ts$1.SyntaxKind.GreaterThanEqualsToken;
-}
-function isIndexMethodCall(node) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && indexMethods.has(node.expression.name.text) && node;
-}
-//#endregion
-export { arrayExistenceChecksConsistency_default as default };
-
-//# sourceMappingURL=arrayExistenceChecksConsistency.js.map

package/lib/rules/arrayFilteredFinds.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.filter()` when only the first or last matching element is needed.";
-    readonly id: "arrayFilteredFinds";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferFind" | "preferFindLast", undefined>;
-export default _default;
-//# sourceMappingURL=arrayFilteredFinds.d.ts.map

package/lib/rules/arrayFilteredFinds.js

@@ -1,80 +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/arrayFilteredFinds.ts
-function isArrayFilterCall(node, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "filter" && !!node.arguments.length && node.arguments.length <= 2 && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
-}
-function isNegativeOneIndex(node) {
-	return ts$1.isPrefixUnaryExpression(node) && node.operator === ts$1.SyntaxKind.MinusToken && ts$1.isNumericLiteral(node.operand) && node.operand.text === "1";
-}
-function isZeroIndex(node) {
-	return ts$1.isNumericLiteral(node) && node.text === "0";
-}
-var arrayFilteredFinds_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.filter()` when only the first or last matching element is needed.",
-		id: "arrayFilteredFinds",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		preferFind: {
-			primary: "Prefer `.find()` over `.filter()[0]`.",
-			secondary: ["Using `.filter()` to get only the first matching element creates an unnecessary intermediate array.", "The `.find()` method is more efficient as it stops iteration once a match is found."],
-			suggestions: ["Replace `.filter(callback)[0]` with `.find(callback)`."]
-		},
-		preferFindLast: {
-			primary: "Prefer `.findLast()` over `.filter().pop()` or `.filter().at(-1)`.",
-			secondary: ["Using `.filter()` to get only the last matching element creates an unnecessary intermediate array.", "The `.findLast()` method is more efficient as it iterates from the end and stops once a match is found."],
-			suggestions: ["Replace `.filter(callback).pop()` or `.filter(callback).at(-1)` with `.findLast(callback)`."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			CallExpression: (node, { sourceFile, typeChecker }) => {
-				if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-				const methodName = node.expression.name.text;
-				const objectExpression = node.expression.expression;
-				switch (methodName) {
-					case "pop":
-						if (!node.arguments.length && isArrayFilterCall(objectExpression, typeChecker)) context.report({
-							message: "preferFindLast",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					case "shift":
-						if (!node.arguments.length && isArrayFilterCall(objectExpression, typeChecker)) context.report({
-							message: "preferFind",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					case "at": if (node.arguments.length === 1) {
-						const arg = node.arguments[0];
-						if (isZeroIndex(arg) && isArrayFilterCall(objectExpression, typeChecker)) {
-							context.report({
-								message: "preferFind",
-								range: getTSNodeRange(node, sourceFile)
-							});
-							return;
-						}
-						if (isNegativeOneIndex(arg) && isArrayFilterCall(objectExpression, typeChecker)) context.report({
-							message: "preferFindLast",
-							range: getTSNodeRange(node, sourceFile)
-						});
-					}
-				}
-			},
-			ElementAccessExpression: (node, { sourceFile, typeChecker }) => {
-				if (isZeroIndex(node.argumentExpression) && isArrayFilterCall(node.expression, typeChecker)) context.report({
-					message: "preferFind",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { arrayFilteredFinds_default as default };
-
-//# sourceMappingURL=arrayFilteredFinds.js.map

package/lib/rules/arrayFinds.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.filter()[0]` instead of `.find()` when looking for a single element.";
-    readonly id: "arrayFinds";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferFind", undefined>;
-export default _default;
-//# sourceMappingURL=arrayFinds.d.ts.map

package/lib/rules/arrayFinds.js

@@ -1,41 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arrayFinds.ts
-var arrayFinds_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.filter()[0]` instead of `.find()` when looking for a single element.",
-		id: "arrayFinds",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferFind: {
-		primary: "Prefer `.find()` over `.filter()[0]` when looking for a single element.",
-		secondary: ["Using `.find()` is more efficient because it stops searching after finding the first match.", "`.filter()[0]` unnecessarily iterates through the entire array."],
-		suggestions: ["Replace `.filter(...)[0]` with `.find(...)`."]
-	} },
-	setup(context) {
-		return { visitors: { ElementAccessExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isNumericLiteral(node.argumentExpression) || node.argumentExpression.text !== "0" || !isFilterCall(node.expression, typeChecker)) return;
-			const arrayText = node.expression.expression.expression.getText(sourceFile);
-			const filterArgumentsText = node.expression.arguments.map((arg) => arg.getText(sourceFile)).join(", ");
-			context.report({
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: `${arrayText}.find(${filterArgumentsText})`
-				},
-				message: "preferFind",
-				range: {
-					begin: node.expression.expression.name.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function isFilterCall(node, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && !!node.arguments.length && node.expression.name.text === "filter" && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression));
-}
-//#endregion
-export { arrayFinds_default as default };
-
-//# sourceMappingURL=arrayFinds.js.map

package/lib/rules/arrayFlatMapMethods.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.map().flat()` when `.flatMap()` can be used.";
-    readonly id: "arrayFlatMapMethods";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferFlatMap", undefined>;
-export default _default;
-//# sourceMappingURL=arrayFlatMapMethods.d.ts.map

package/lib/rules/arrayFlatMapMethods.js

@@ -1,47 +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/arrayFlatMapMethods.ts
-function isArrayMapCall(node, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && node.arguments.length >= 1 && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
-}
-function isFlatCallWithDepthOne(node) {
-	switch (node.arguments.length) {
-		case 0: return true;
-		case 1: {
-			const firstArgument = node.arguments[0];
-			return ts$1.isNumericLiteral(firstArgument) && firstArgument.text === "1";
-		}
-		default: return false;
-	}
-}
-var arrayFlatMapMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.map().flat()` when `.flatMap()` can be used.",
-		id: "arrayFlatMapMethods",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferFlatMap: {
-		primary: "Prefer `.flatMap()` over `.map().flat()`.",
-		secondary: ["`.flatMap()` combines mapping and flattening in a single step, which is more concise and efficient.", "Using `.map().flat()` creates an intermediate array that is immediately discarded."],
-		suggestions: ["Replace `.map(callback).flat()` with `.flatMap(callback)`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			if (node.expression.name.text !== "flat") return;
-			if (!isFlatCallWithDepthOne(node)) return;
-			const objectExpression = node.expression.expression;
-			if (!isArrayMapCall(objectExpression, typeChecker)) return;
-			context.report({
-				message: "preferFlatMap",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arrayFlatMapMethods_default as default };
-
-//# sourceMappingURL=arrayFlatMapMethods.js.map

package/lib/rules/arrayFlatMethods.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports legacy techniques to flatten arrays instead of using `.flat()`.";
-    readonly id: "arrayFlatMethods";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferFlat", undefined>;
-export default _default;
-//# sourceMappingURL=arrayFlatMethods.d.ts.map