@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/arrayEmptyCallbackSlots.js

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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferEqualsMinusOne" | "preferNotEqualsMinusOne", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayExistenceChecksConsistency.d.ts.map

package/lib/rules/arrayExistenceChecksConsistency.js

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

@@ -0,0 +1,10 @@
+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: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferFind" | "preferFindLast", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayFilteredFinds.d.ts.map

package/lib/rules/arrayFilteredFinds.js

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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferFind", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayFinds.d.ts.map

package/lib/rules/arrayFinds.js

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

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

package/lib/rules/arrayFlatMapMethods.js

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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferFlat", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayFlatMethods.d.ts.map

package/lib/rules/arrayFlatMethods.js

@@ -0,0 +1,83 @@
+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 };
+
+//# sourceMappingURL=arrayFlatMethods.js.map

package/lib/rules/arrayFlatUnnecessaryDepths.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryDepth", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayFlatUnnecessaryDepths.d.ts.map

package/lib/rules/arrayFlatUnnecessaryDepths.js

@@ -0,0 +1,33 @@
+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/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 (!ts$1.isNumericLiteral(arg) || arg.text !== "1") return;
+			if (!isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
+			context.report({
+				message: "unnecessaryDepth",
+				range: getTSNodeRange(arg, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { arrayFlatUnnecessaryDepths_default as default };
+
+//# sourceMappingURL=arrayFlatUnnecessaryDepths.js.map

package/lib/rules/arrayIncludes.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferIncludes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayIncludes.d.ts.map

package/lib/rules/arrayIncludes.js

@@ -0,0 +1,59 @@
+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";
+//#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 isZeroValue = isZero(comparedValue);
+	const indexOfOnLeft = ts$1.isCallExpression(left);
+	return (isNegativeOne(comparedValue) && (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) || isZeroValue && (indexOfOnLeft && kind === ts$1.SyntaxKind.GreaterThanEqualsToken || !indexOfOnLeft && kind === ts$1.SyntaxKind.LessThanEqualsToken)) && {
+		indexOfCall,
+		node
+	};
+}
+function isNegativeOne(node) {
+	return ts$1.isPrefixUnaryExpression(node) && node.operator === ts$1.SyntaxKind.MinusToken && ts$1.isNumericLiteral(node.operand) && node.operand.text === "1";
+}
+function isZero(node) {
+	return ts$1.isNumericLiteral(node) && node.text === "0";
+}
+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 };
+
+//# sourceMappingURL=arrayIncludes.js.map

package/lib/rules/arrayIncludesMethods.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferIncludes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayIncludesMethods.d.ts.map

package/lib/rules/arrayIncludesMethods.js

@@ -0,0 +1,37 @@
+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 };
+
+//# sourceMappingURL=arrayIncludesMethods.js.map

package/lib/rules/arrayIndexOfMethods.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferIndexOf" | "preferLastIndexOf", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayIndexOfMethods.d.ts.map