@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/arrayIndexOfMethods.js

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

package/lib/rules/arrayLoops.d.ts

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

package/lib/rules/arrayLoops.js

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

package/lib/rules/arrayMapIdentities.d.ts

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

package/lib/rules/arrayMapIdentities.js

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

package/lib/rules/arrayMutableReverses.d.ts

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

package/lib/rules/arrayMutableReverses.js

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

package/lib/rules/arrayMutableSorts.d.ts

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

package/lib/rules/arrayMutableSorts.js

@@ -0,0 +1,72 @@
+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 = new Set([
+	"concat",
+	"entries",
+	"filter",
+	"flat",
+	"flatMap",
+	"from",
+	"keys",
+	"map",
+	"of",
+	"slice",
+	"split",
+	"values"
+]);
+const objectStaticMethods = 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 };
+
+//# sourceMappingURL=arrayMutableSorts.js.map

package/lib/rules/arrayReduceTypeArguments.d.ts

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

package/lib/rules/arrayReduceTypeArguments.js

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

package/lib/rules/arraySliceUnnecessaryEnd.d.ts

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

package/lib/rules/arraySliceUnnecessaryEnd.js

@@ -0,0 +1,51 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arraySliceUnnecessaryEnd.ts
+var arraySliceUnnecessaryEnd_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.",
+		id: "arraySliceUnnecessaryEnd",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { unnecessaryEnd: {
+		primary: "The `end` argument is unnecessary when slicing to the end of the array or string.",
+		secondary: ["Passing `.length` or `Infinity` as the `end` argument is unnecessary.", "The `.slice()` method defaults to the end when the second argument is omitted."],
+		suggestions: ["Remove the unnecessary `end` argument."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile }) => {
+			if (!ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "slice" || node.arguments.length !== 2) return;
+			const endArgument = node.arguments[1];
+			if (!isUnnecessaryEnd(node.expression.expression, endArgument, sourceFile)) return;
+			context.report({
+				fix: {
+					range: {
+						begin: node.arguments[0].getEnd(),
+						end: endArgument.getEnd()
+					},
+					text: ""
+				},
+				message: "unnecessaryEnd",
+				range: getTSNodeRange(endArgument, sourceFile)
+			});
+		} } };
+	}
+});
+function isInfinity(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.Identifier: return node.text === "Infinity";
+		case ts$1.SyntaxKind.PropertyAccessExpression: return ts$1.isIdentifier(node.expression) && node.expression.text === "Number" && node.name.text === "POSITIVE_INFINITY";
+		default: return false;
+	}
+}
+function isLengthOfReceiver(receiver, endArgument, sourceFile) {
+	return ts$1.isPropertyAccessExpression(endArgument) && endArgument.name.text === "length" && hasSameTokens(receiver, endArgument.expression, sourceFile);
+}
+function isUnnecessaryEnd(receiver, endArgument, sourceFile) {
+	return isInfinity(endArgument) || isLengthOfReceiver(receiver, endArgument, sourceFile);
+}
+//#endregion
+export { arraySliceUnnecessaryEnd_default as default };
+
+//# sourceMappingURL=arraySliceUnnecessaryEnd.js.map

package/lib/rules/arraySomeMethods.d.ts

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

package/lib/rules/arraySomeMethods.js

@@ -0,0 +1,77 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arraySomeMethods.ts
+var arraySomeMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports patterns that can be replaced with `.some()` for checking array element existence.",
+		id: "arraySomeMethods",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferSome: {
+		primary: "Prefer `.some()` to more cleanly check if an array contains a matching element.",
+		secondary: ["The `.some()` method is more explicit and efficient for existence checks.", "It stops iterating as soon as a match is found."],
+		suggestions: ["Replace with `.some()`."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
+			const result = checkFilterLengthComparison(node, typeChecker) ?? checkFindIndexComparison(node, typeChecker);
+			if (!result) return;
+			const arrayText = result.arrayExpression.getText(sourceFile);
+			const callbackText = result.callback.getText(sourceFile);
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: `${arrayText}.some(${callbackText})`
+				},
+				message: "preferSome",
+				range
+			});
+		} } };
+	}
+});
+function checkFilterLengthComparison(node, typeChecker) {
+	const lengthAccess = isNonZeroLengthCheck(node) && getLengthAccess(node);
+	return lengthAccess ? getFilterCall(lengthAccess.expression, typeChecker) : void 0;
+}
+function checkFindIndexComparison(node, typeChecker) {
+	return isFindIndexNegativeOneCheck(node) && ts$1.isCallExpression(node.left) && getFindIndexCall(node.left, typeChecker);
+}
+function getFilterCall(node, typeChecker) {
+	if (!ts$1.isCallExpression(node) || !ts$1.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "filter" || !node.arguments.length || !isArrayType(node.expression.expression, typeChecker)) return;
+	return {
+		arrayExpression: node.expression.expression,
+		callback: node.arguments[0]
+	};
+}
+function getFindIndexCall(node, typeChecker) {
+	if (!ts$1.isPropertyAccessExpression(node.expression) || !["findIndex", "findLastIndex"].includes(node.expression.name.text) || !node.arguments.length || !isArrayType(node.expression.expression, typeChecker)) return;
+	return {
+		arrayExpression: node.expression.expression,
+		callback: node.arguments[0]
+	};
+}
+function getLengthAccess(node) {
+	return ts$1.isPropertyAccessExpression(node.left) && node.left.name.text === "length" && node.left;
+}
+function isArrayType(node, typeChecker) {
+	const type = typeChecker.getTypeAtLocation(node);
+	return typeChecker.isArrayType(type);
+}
+function isFindIndexNegativeOneCheck(node) {
+	if (node.operatorToken.kind !== ts$1.SyntaxKind.ExclamationEqualsEqualsToken || !ts$1.isPrefixUnaryExpression(node.right) || node.right.operator !== ts$1.SyntaxKind.MinusToken || !ts$1.isNumericLiteral(node.right.operand)) return false;
+	return node.right.operand.text === "1";
+}
+function isNonZeroLengthCheck(node) {
+	const { left, operatorToken, right } = node;
+	if (operatorToken.kind === ts$1.SyntaxKind.GreaterThanToken && ts$1.isNumericLiteral(right) && right.text === "0") return true;
+	if (operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken && ts$1.isNumericLiteral(right) && right.text === "0") return true;
+	if (operatorToken.kind === ts$1.SyntaxKind.GreaterThanEqualsToken && ts$1.isNumericLiteral(right) && right.text === "1") return true;
+	if (operatorToken.kind === ts$1.SyntaxKind.LessThanToken && ts$1.isNumericLiteral(left) && left.text === "0") return true;
+	return false;
+}
+//#endregion
+export { arraySomeMethods_default as default };
+
+//# sourceMappingURL=arraySomeMethods.js.map

package/lib/rules/arrayTernarySpreadingConsistency.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports inconsistent types when spreading a ternary in an array literal.";
+    readonly id: "arrayTernarySpreadingConsistency";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "inconsistentTypes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayTernarySpreadingConsistency.d.ts.map

package/lib/rules/arrayTernarySpreadingConsistency.js

@@ -0,0 +1,74 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arrayTernarySpreadingConsistency.ts
+var arrayTernarySpreadingConsistency_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent types when spreading a ternary in an array literal.",
+		id: "arrayTernarySpreadingConsistency",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { inconsistentTypes: {
+		primary: "Prefer consistent types in both branches when spreading a ternary in an array.",
+		secondary: ["Mixing array and string types in ternary spread branches reduces code clarity.", "Both branches should use the same type: either arrays or strings."],
+		suggestions: ["Replace the empty string with an empty array."]
+	} },
+	setup(context) {
+		return { visitors: { ArrayLiteralExpression: (node, { sourceFile }) => {
+			for (const element of node.elements) {
+				if (!ts$1.isSpreadElement(element) || !ts$1.isParenthesizedExpression(element.expression)) continue;
+				const inner = element.expression.expression;
+				if (!ts$1.isConditionalExpression(inner)) continue;
+				const whenTrue = unwrapParentheses(inner.whenTrue);
+				const whenFalse = unwrapParentheses(inner.whenFalse);
+				if (ts$1.isArrayLiteralExpression(whenTrue) && isStringLike(whenFalse) && isEmptyStringLike(whenFalse)) {
+					context.report({
+						fix: {
+							range: {
+								begin: whenFalse.getStart(sourceFile),
+								end: whenFalse.getEnd()
+							},
+							text: "[]"
+						},
+						message: "inconsistentTypes",
+						range: {
+							begin: whenFalse.getStart(sourceFile),
+							end: whenFalse.getEnd()
+						}
+					});
+					continue;
+				}
+				if (isStringLike(whenTrue) && ts$1.isArrayLiteralExpression(whenFalse) && isEmptyArray(whenFalse)) context.report({
+					fix: {
+						range: {
+							begin: whenFalse.getStart(sourceFile),
+							end: whenFalse.getEnd()
+						},
+						text: "''"
+					},
+					message: "inconsistentTypes",
+					range: {
+						begin: whenFalse.getStart(sourceFile),
+						end: whenFalse.getEnd()
+					}
+				});
+			}
+		} } };
+	}
+});
+function isEmptyArray(node) {
+	return ts$1.isArrayLiteralExpression(node) && !node.elements.length;
+}
+function isEmptyStringLike(node) {
+	return isStringLike(node) && node.text === "";
+}
+function isStringLike(node) {
+	return ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node);
+}
+function unwrapParentheses(node) {
+	return ts$1.isParenthesizedExpression(node) ? unwrapParentheses(node.expression) : node;
+}
+//#endregion
+export { arrayTernarySpreadingConsistency_default as default };
+
+//# sourceMappingURL=arrayTernarySpreadingConsistency.js.map

package/lib/rules/arrayTypes.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports array type syntax that doesn't match the configured style.";
+    readonly id: "arrayTypes";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferArraySyntax" | "preferGenericSyntax" | "preferReadonlyArraySyntax" | "preferReadonlyGenericSyntax", {
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        array: "array";
+        "array-simple": "array-simple";
+        generic: "generic";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=arrayTypes.d.ts.map