@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/arrayTypes.js

@@ -0,0 +1,111 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/arrayTypes.ts
+function isSimpleType(typeNode) {
+	switch (typeNode?.kind) {
+		case ts$1.SyntaxKind.AnyKeyword:
+		case ts$1.SyntaxKind.BigIntKeyword:
+		case ts$1.SyntaxKind.BooleanKeyword:
+		case ts$1.SyntaxKind.NeverKeyword:
+		case ts$1.SyntaxKind.NumberKeyword:
+		case ts$1.SyntaxKind.ObjectKeyword:
+		case ts$1.SyntaxKind.StringKeyword:
+		case ts$1.SyntaxKind.SymbolKeyword:
+		case ts$1.SyntaxKind.TypeReference:
+		case ts$1.SyntaxKind.UndefinedKeyword:
+		case ts$1.SyntaxKind.UnknownKeyword:
+		case ts$1.SyntaxKind.VoidKeyword: return true;
+		case ts$1.SyntaxKind.ArrayType: return isSimpleType(typeNode.elementType);
+		default: return false;
+	}
+}
+var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports array type syntax that doesn't match the configured style.",
+		id: "arrayTypes",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		preferArraySyntax: {
+			primary: "Prefer `T[]` over `Array<T>`.",
+			secondary: ["TypeScript provides two equivalent ways to define an array type: `T[]` and `Array<T>`.", "Using the shorthand `T[]` syntax consistently is more concise and idiomatic."],
+			suggestions: ["Replace `Array<T>` with `T[]`."]
+		},
+		preferGenericSyntax: {
+			primary: "Prefer `Array<T>` over `T[]`.",
+			secondary: ["TypeScript provides two equivalent ways to define an array type: `T[]` and `Array<T>`.", "Using the generic `Array<T>` syntax consistently can be clearer for complex types."],
+			suggestions: ["Replace `T[]` with `Array<T>`."]
+		},
+		preferReadonlyArraySyntax: {
+			primary: "Prefer `readonly T[]` over `ReadonlyArray<T>`.",
+			secondary: ["TypeScript provides two equivalent ways to define a readonly array type: `readonly T[]` and `ReadonlyArray<T>`.", "Using the shorthand `readonly T[]` syntax consistently is more concise and idiomatic."],
+			suggestions: ["Replace `ReadonlyArray<T>` with `readonly T[]`."]
+		},
+		preferReadonlyGenericSyntax: {
+			primary: "Prefer `ReadonlyArray<T>` over `readonly T[]`.",
+			secondary: ["TypeScript provides two equivalent ways to define a readonly array type: `readonly T[]` and `ReadonlyArray<T>`.", "Using the generic `ReadonlyArray<T>` syntax consistently can be clearer for complex types."],
+			suggestions: ["Replace `readonly T[]` with `ReadonlyArray<T>`."]
+		}
+	},
+	options: { style: z.enum([
+		"array",
+		"array-simple",
+		"generic"
+	]).default("array").describe("Which array type syntax to enforce: 'array' for `T[]`, 'generic' for `Array<T>`, or 'array-simple' for `T[]` only with simple types.") },
+	setup(context) {
+		return { visitors: {
+			ArrayType: (node, { options, sourceFile }) => {
+				if (node.parent.kind === ts$1.SyntaxKind.TypeOperator && node.parent.operator === ts$1.SyntaxKind.ReadonlyKeyword) return;
+				switch (options.style) {
+					case "array": return;
+					case "array-simple":
+						if (isSimpleType(node.elementType)) return;
+						break;
+					case "generic": break;
+				}
+				context.report({
+					message: "preferGenericSyntax",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			TypeOperator: (node, { options, sourceFile }) => {
+				if (node.operator !== ts$1.SyntaxKind.ReadonlyKeyword || node.type.kind !== ts$1.SyntaxKind.ArrayType) return;
+				const arrayType = node.type;
+				switch (options.style) {
+					case "array": return;
+					case "array-simple":
+						if (isSimpleType(arrayType.elementType)) return;
+						break;
+					case "generic": break;
+				}
+				context.report({
+					message: "preferReadonlyGenericSyntax",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			TypeReference: (node, { options, sourceFile, typeChecker }) => {
+				if (node.typeName.kind !== ts$1.SyntaxKind.Identifier || !isGlobalDeclaration(node.typeName, typeChecker)) return;
+				const typeName = node.typeName.text;
+				if (typeName !== "Array" && typeName !== "ReadonlyArray") return;
+				const typeArg = node.typeArguments?.[0];
+				switch (options.style) {
+					case "array": break;
+					case "array-simple":
+						if (!isSimpleType(typeArg)) return;
+						break;
+					case "generic": return;
+				}
+				context.report({
+					message: typeName === "Array" ? "preferArraySyntax" : "preferReadonlyArraySyntax",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { arrayTypes_default as default };
+
+//# sourceMappingURL=arrayTypes.js.map

package/lib/rules/arrayUnnecessaryLengthChecks.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary array length checks before `.some()` or `.every()` calls.";
+    readonly id: "arrayUnnecessaryLengthChecks";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryLengthCheckEvery" | "unnecessaryLengthCheckSome", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayUnnecessaryLengthChecks.d.ts.map

package/lib/rules/arrayUnnecessaryLengthChecks.js

@@ -0,0 +1,97 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arrayUnnecessaryLengthChecks.ts
+function haveSameArrayExpression(expr1, expr2, sourceFile) {
+	return expr1.getText(sourceFile) === expr2.getText(sourceFile);
+}
+function isLengthNonZeroCheck(node) {
+	const { left, operatorToken, right } = node;
+	if (operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken) {
+		if (isLengthProperty(left) && isZero(right)) return { arrayExpression: left.expression };
+		if (isZero(left) && isLengthProperty(right)) return { arrayExpression: right.expression };
+	}
+	if (operatorToken.kind === ts$1.SyntaxKind.GreaterThanToken && isLengthProperty(left) && isZero(right)) return { arrayExpression: left.expression };
+}
+function isLengthProperty(node) {
+	return ts$1.isPropertyAccessExpression(node) && node.name.text === "length";
+}
+function isLengthZeroCheck(node) {
+	const { left, operatorToken, right } = node;
+	if (operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken) {
+		if (isLengthProperty(left) && isZero(right)) return {
+			arrayExpression: left.expression,
+			isZeroCheck: true
+		};
+		if (isZero(left) && isLengthProperty(right)) return {
+			arrayExpression: right.expression,
+			isZeroCheck: true
+		};
+	}
+}
+function isSomeOrEveryCall(node, methodName) {
+	if (!ts$1.isCallExpression(node)) return;
+	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+	if (node.expression.name.text !== methodName) return;
+	return node.expression.expression;
+}
+function isZero(node) {
+	return ts$1.isNumericLiteral(node) && node.text === "0";
+}
+var arrayUnnecessaryLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary array length checks before `.some()` or `.every()` calls.",
+		id: "arrayUnnecessaryLengthChecks",
+		presets: ["logical"]
+	},
+	messages: {
+		unnecessaryLengthCheckEvery: {
+			primary: "Unnecessary length check before `.every()`.",
+			secondary: ["`.every()` returns `true` for an empty array, so checking `array.length === 0` before calling `.every()` is redundant."],
+			suggestions: ["Remove the length check."]
+		},
+		unnecessaryLengthCheckSome: {
+			primary: "Unnecessary length check before `.some()`.",
+			secondary: ["`.some()` returns `false` for an empty array, so checking `array.length !== 0` or `array.length > 0` before calling `.some()` is redundant."],
+			suggestions: ["Remove the length check."]
+		}
+	},
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken) {
+				const { left, right } = node;
+				if (!ts$1.isBinaryExpression(left)) return;
+				const nonZeroCheck = isLengthNonZeroCheck(left);
+				if (!nonZeroCheck) return;
+				const someArrayExpr = isSomeOrEveryCall(right, "some");
+				if (someArrayExpr && haveSameArrayExpression(nonZeroCheck.arrayExpression, someArrayExpr, sourceFile)) context.report({
+					fix: {
+						range: getTSNodeRange(node, sourceFile),
+						text: right.getText(sourceFile)
+					},
+					message: "unnecessaryLengthCheckSome",
+					range: getTSNodeRange(left, sourceFile)
+				});
+			}
+			if (node.operatorToken.kind === ts$1.SyntaxKind.BarBarToken) {
+				const { left, right } = node;
+				if (!ts$1.isBinaryExpression(left)) return;
+				const zeroCheck = isLengthZeroCheck(left);
+				if (!zeroCheck) return;
+				const everyArrayExpr = isSomeOrEveryCall(right, "every");
+				if (everyArrayExpr && haveSameArrayExpression(zeroCheck.arrayExpression, everyArrayExpr, sourceFile)) context.report({
+					fix: {
+						range: getTSNodeRange(node, sourceFile),
+						text: right.getText(sourceFile)
+					},
+					message: "unnecessaryLengthCheckEvery",
+					range: getTSNodeRange(left, sourceFile)
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { arrayUnnecessaryLengthChecks_default as default };
+
+//# sourceMappingURL=arrayUnnecessaryLengthChecks.js.map

package/lib/rules/asConstAssertions.d.ts

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

package/lib/rules/asConstAssertions.js

@@ -0,0 +1,57 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/asConstAssertions.ts
+function getTextValue(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.FalseKeyword: return "false";
+		case ts$1.SyntaxKind.LiteralType: return getTextValue(node.literal);
+		case ts$1.SyntaxKind.NumericLiteral: return node.text;
+		case ts$1.SyntaxKind.StringLiteral: return node.text;
+		case ts$1.SyntaxKind.TrueKeyword: return "true";
+	}
+}
+function isLiteralType(node) {
+	return ts$1.isLiteralTypeNode(node) && (ts$1.isStringLiteral(node.literal) || ts$1.isNumericLiteral(node.literal) || node.literal.kind === ts$1.SyntaxKind.TrueKeyword || node.literal.kind === ts$1.SyntaxKind.FalseKeyword);
+}
+var asConstAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using explicit literal types when `as const` can be used.",
+		id: "asConstAssertions",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		preferAsConst: {
+			primary: "Prefer `as const` over an explicit literal type assertion.",
+			secondary: ["`as const` tells TypeScript to infer the literal type automatically.", "This avoids repeating the literal value and is more concise."],
+			suggestions: ["Replace the explicit literal type with `as const`."]
+		},
+		preferAsConstAnnotation: {
+			primary: "Prefer `as const` over a literal type annotation.",
+			secondary: ["When the literal type matches the initializer value, use `as const` instead.", "This avoids repeating the literal value and is more concise."],
+			suggestions: ["Remove the type annotation and add `as const` to the initializer."]
+		}
+	},
+	setup(context) {
+		function compareTypes(expressionNode, typeNode, message, sourceFile) {
+			if (getTextValue(typeNode) === void 0) return;
+			if (getTextValue(expressionNode) === void 0) return;
+			context.report({
+				message,
+				range: getTSNodeRange(typeNode, sourceFile)
+			});
+		}
+		return { visitors: {
+			AsExpression: (node, { sourceFile }) => {
+				if (isLiteralType(node.type)) compareTypes(node.expression, node.type, "preferAsConst", sourceFile);
+			},
+			VariableDeclaration: (node, { sourceFile }) => {
+				if (node.initializer && node.type && isLiteralType(node.type)) compareTypes(node.initializer, node.type, "preferAsConstAnnotation", sourceFile);
+			}
+		} };
+	}
+});
+//#endregion
+export { asConstAssertions_default as default };
+
+//# sourceMappingURL=asConstAssertions.js.map

package/lib/rules/assignmentOperatorShorthands.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer logical assignment operator shorthand expressions.";
+    readonly id: "assignmentOperatorShorthands";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferShorthand", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=assignmentOperatorShorthands.d.ts.map

package/lib/rules/assignmentOperatorShorthands.js

@@ -0,0 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/assignmentOperatorShorthands.ts
+var assignmentOperatorShorthands_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer logical assignment operator shorthand expressions.",
+		id: "assignmentOperatorShorthands",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferShorthand: {
+		primary: "Prefer the logical assignment operator shorthand `{{ operator }}`.",
+		secondary: ["Logical assignment operators are more concise and express the intent more clearly.", "They were introduced in ES2021 and are supported in all modern environments."],
+		suggestions: ["Use the shorthand operator `{{ operator }}`."]
+	} },
+	setup(context) {
+		function getShorthand(kind) {
+			switch (kind) {
+				case ts$1.SyntaxKind.AmpersandAmpersandToken: return "&&=";
+				case ts$1.SyntaxKind.BarBarToken: return "||=";
+				case ts$1.SyntaxKind.QuestionQuestionToken: return "??=";
+				default: return;
+			}
+		}
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || !ts$1.isBinaryExpression(node.right)) return;
+			const shorthand = getShorthand(node.right.operatorToken.kind);
+			if (!shorthand) return;
+			if (!hasSameTokens(node.left, node.right.left, sourceFile)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			const fixedText = `${node.left.getText(sourceFile)} ${shorthand} ${node.right.right.getText(sourceFile)}`;
+			context.report({
+				data: { operator: shorthand },
+				fix: {
+					range,
+					text: fixedText
+				},
+				message: "preferShorthand",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { assignmentOperatorShorthands_default as default };
+
+//# sourceMappingURL=assignmentOperatorShorthands.js.map

package/lib/rules/asyncPromiseExecutors.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using async functions as Promise executor functions.";
     readonly id: "asyncPromiseExecutors";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "asyncPromiseExecutor", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "asyncPromiseExecutor", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=asyncPromiseExecutors.d.ts.map

package/lib/rules/asyncPromiseExecutors.js

@@ -1,51 +1,41 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using async functions as Promise executor functions.",
-        id: "asyncPromiseExecutors",
-        preset: "logical",
-    },
-    messages: {
-        asyncPromiseExecutor: {
-            primary: "Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
-            secondary: [
-                "The Promise executor function is called synchronously by the Promise constructor.",
-                "If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
-                "Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor.",
-            ],
-            suggestions: [
-                "Remove the `async` keyword from the executor function.",
-                "If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                NewExpression: (node) => {
-                    if (!isGlobalDeclaration(node.expression, context.typeChecker) ||
-                        !node.arguments?.length) {
-                        return;
-                    }
-                    const executor = node.arguments[0];
-                    if (!ts.isFunctionLike(executor)) {
-                        return;
-                    }
-                    const asyncModifier = executor.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.AsyncKeyword);
-                    if (!asyncModifier) {
-                        return;
-                    }
-                    context.report({
-                        message: "asyncPromiseExecutor",
-                        range: {
-                            begin: asyncModifier.getStart(context.sourceFile),
-                            end: asyncModifier.getEnd(),
-                        },
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/asyncPromiseExecutors.ts
+var asyncPromiseExecutors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using async functions as Promise executor functions.",
+		id: "asyncPromiseExecutors",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { asyncPromiseExecutor: {
+		primary: "Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
+		secondary: [
+			"The Promise executor function is called synchronously by the Promise constructor.",
+			"If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
+			"Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor."
+		],
+		suggestions: ["Remove the `async` keyword from the executor function.", "If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+			if (!isGlobalDeclaration(node.expression, typeChecker) || !node.arguments?.length) return;
+			const executor = nullThrows(node.arguments[0], "Expected there to be a promise executor!");
+			if (executor.kind !== SyntaxKind.FunctionExpression && executor.kind !== SyntaxKind.ArrowFunction) return;
+			const asyncModifier = executor.modifiers?.find((mod) => mod.kind === SyntaxKind.AsyncKeyword);
+			if (!asyncModifier) return;
+			context.report({
+				message: "asyncPromiseExecutor",
+				range: {
+					begin: asyncModifier.getStart(sourceFile),
+					end: asyncModifier.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { asyncPromiseExecutors_default as default };
+
+//# sourceMappingURL=asyncPromiseExecutors.js.map

package/lib/rules/asyncUnnecessaryPromiseWrappers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.";
+    readonly id: "asyncUnnecessaryPromiseWrappers";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryReject" | "unnecessaryResolve", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=asyncUnnecessaryPromiseWrappers.d.ts.map

package/lib/rules/asyncUnnecessaryPromiseWrappers.js

@@ -0,0 +1,52 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/asyncUnnecessaryPromiseWrappers.ts
+var asyncUnnecessaryPromiseWrappers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.",
+		id: "asyncUnnecessaryPromiseWrappers",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		unnecessaryReject: {
+			primary: "Errors can be thrown directly instead of wrapping in `Promise.reject()`.",
+			secondary: ["In async functions, thrown errors are automatically converted to rejected promises.", "Using `Promise.reject()` is unnecessary and less idiomatic."],
+			suggestions: ["Throw the error directly instead of using `Promise.reject()`."]
+		},
+		unnecessaryResolve: {
+			primary: "Return values in async functions are already wrapped in a `Promise`.",
+			secondary: ["Wrapping a value in `Promise.resolve()` is unnecessary in async functions.", "This adds extra code without changing the behavior."],
+			suggestions: ["Return the value directly instead of wrapping it."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ArrowFunction: (node, { sourceFile }) => {
+			if (!isAsyncFunction(node) || !ts$1.isCallExpression(node.body)) return;
+			const message = getMessageForBody(node.body);
+			if (!message) return;
+			context.report({
+				message,
+				range: {
+					begin: node.body.getStart(sourceFile),
+					end: node.body.getEnd()
+				}
+			});
+		} } };
+	}
+});
+function getMessageForBody(node) {
+	if (!ts$1.isPropertyAccessExpression(node.expression) || !ts$1.isIdentifier(node.expression.expression) || node.expression.expression.text !== "Promise") return;
+	switch (node.expression.name.text) {
+		case "reject": return "unnecessaryReject";
+		case "resolve": return "unnecessaryResolve";
+		default: return;
+	}
+}
+function isAsyncFunction(node) {
+	return node.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
+}
+//#endregion
+export { asyncUnnecessaryPromiseWrappers_default as default };
+
+//# sourceMappingURL=asyncUnnecessaryPromiseWrappers.js.map

package/lib/rules/atAccesses.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer using .at() for accessing elements at negative indices.";
+    readonly id: "atAccesses";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferAt", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=atAccesses.d.ts.map

package/lib/rules/atAccesses.js

@@ -0,0 +1,52 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/atAccesses.ts
+var atAccesses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer using .at() for accessing elements at negative indices.",
+		id: "atAccesses",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferAt: {
+		primary: "Prefer using .at() with a negative index instead of calculating length minus an offset.",
+		secondary: ["The .at() method provides a cleaner way to access elements from the end of an array or string.", "Using .at(-1) is more readable than array[array.length - 1]."],
+		suggestions: ["Use .at() with a negative index to access elements from the end."]
+	} },
+	setup(context) {
+		return { visitors: { ElementAccessExpression: (node, { sourceFile }) => {
+			if (!isLeftHandSide(node) && isLengthMinusAccess(node, sourceFile)) context.report({
+				message: "preferAt",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+function isLeftHandSide(node) {
+	switch (node.parent.kind) {
+		case ts$1.SyntaxKind.ArrayLiteralExpression: return ts$1.isBinaryExpression(node.parent.parent) && tsutils.isAssignmentKind(node.parent.parent.operatorToken.kind) && node.parent.parent.left === node.parent;
+		case ts$1.SyntaxKind.BinaryExpression: return tsutils.isAssignmentKind(node.parent.operatorToken.kind) && node.parent.left === node;
+		case ts$1.SyntaxKind.DeleteExpression: return true;
+		case ts$1.SyntaxKind.PostfixUnaryExpression:
+		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operand === node;
+		case ts$1.SyntaxKind.PropertyAssignment:
+		case ts$1.SyntaxKind.ShorthandPropertyAssignment: return node.parent.parent.parent.kind === ts$1.SyntaxKind.BinaryExpression && tsutils.isAssignmentKind(node.parent.parent.parent.operatorToken.kind) && node.parent.parent.parent.left === node.parent.parent;
+	}
+	return false;
+}
+function isLengthMinusAccess(node, sourceFile) {
+	const argument = unwrapParenthesizedNode(node.argumentExpression);
+	if (!ts$1.isBinaryExpression(argument) || argument.operatorToken.kind !== ts$1.SyntaxKind.MinusToken) return false;
+	const left = unwrapParenthesizedNode(argument.left);
+	if (!ts$1.isPropertyAccessExpression(left) || left.name.text !== "length" || !hasSameTokens(left.expression, node.expression, sourceFile)) return false;
+	const right = unwrapParenthesizedNode(argument.right);
+	if (!ts$1.isNumericLiteral(right)) return false;
+	const offset = Number(right.text);
+	if (!Number.isInteger(offset) || offset <= 0) return false;
+	return true;
+}
+//#endregion
+export { atAccesses_default as default };
+
+//# sourceMappingURL=atAccesses.js.map

package/lib/rules/builtinCoercions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.";
+    readonly id: "builtinCoercions";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useBuiltin", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=builtinCoercions.d.ts.map