@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/arraySliceUnnecessaryEnd.js

@@ -1,49 +0,0 @@
-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 };

package/lib/rules/arraySomeMethods.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSome", undefined>;
-export default _default;

package/lib/rules/arraySomeMethods.js

@@ -1,75 +0,0 @@
-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 };

package/lib/rules/arrayTernarySpreadingConsistency.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "inconsistentTypes", undefined>;
-export default _default;

package/lib/rules/arrayTernarySpreadingConsistency.js

@@ -1,72 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/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 };

package/lib/rules/arrayTypes.d.ts

@@ -1,16 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferArraySyntax" | "preferGenericSyntax" | "preferReadonlyArraySyntax" | "preferReadonlyGenericSyntax", {
-    style: z.ZodDefault<z.ZodEnum<{
-        array: "array";
-        "array-simple": "array-simple";
-        generic: "generic";
-    }>>;
-}>;
-export default _default;

package/lib/rules/arrayTypes.js

@@ -1,109 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import { z as z$1 } 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$1.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, program, sourceFile, typeChecker }) => {
-				if (node.typeName.kind !== ts$1.SyntaxKind.Identifier || !isGlobalDeclaration(node.typeName, typeChecker, program)) 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 };

package/lib/rules/arrayUnnecessaryLengthChecks.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryLengthCheckEvery" | "unnecessaryLengthCheckSome", undefined>;
-export default _default;

package/lib/rules/arrayUnnecessaryLengthChecks.js

@@ -1,95 +0,0 @@
-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 };

package/lib/rules/asConstAssertions.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferAsConst" | "preferAsConstAnnotation", undefined>;
-export default _default;

package/lib/rules/asConstAssertions.js

@@ -1,55 +0,0 @@
-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 };

package/lib/rules/assignmentOperatorShorthands.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer logical assignment operator shorthand expressions.";
-    readonly id: "assignmentOperatorShorthands";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferShorthand", undefined>;
-export default _default;

package/lib/rules/assignmentOperatorShorthands.js

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

package/lib/rules/asyncFunctionAwaits.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports async functions that do not use await.";
-    readonly id: "asyncFunctionAwaits";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingAwait", undefined>;
-export default _default;

package/lib/rules/asyncFunctionAwaits.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/asyncFunctionAwaits.ts
-var asyncFunctionAwaits_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports async functions that do not use await.",
-		id: "asyncFunctionAwaits",
-		presets: ["logicalStrict"]
-	},
-	messages: { missingAwait: {
-		primary: "This function is marked `async` but does not contain an `await` expression or return a Promise.",
-		secondary: ["Async functions always wrap their return value in a Promise, which adds overhead if you're not using await.", "This may indicate incomplete implementation or leftover code after refactoring."],
-		suggestions: ["Add an `await` expression if you need to wait for asynchronous operations.", "Remove the `async` keyword if the function doesn't need to be asynchronous."]
-	} },
-	setup(context) {
-		function checkFunction(node, { sourceFile, typeChecker }) {
-			const asyncModifier = node.modifiers?.find((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
-			if (!asyncModifier || node.asteriskToken || !node.body || isEmptyBody(node.body) || checkForAwait(node.body) || bodyReturnsThenable(node.body, typeChecker)) return;
-			context.report({
-				message: "missingAwait",
-				range: getTSNodeRange(asyncModifier, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: checkFunction,
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-			MethodDeclaration: checkFunction
-		} };
-	}
-});
-function bodyReturnsThenable(body, typeChecker) {
-	if (!ts$1.isBlock(body)) return tsutils.isThenableType(typeChecker, body);
-	function checkReturnStatements(node) {
-		if (ts$1.isReturnStatement(node) && node.expression && tsutils.isThenableType(typeChecker, node.expression)) return true;
-		if (tsutils.isFunctionScopeBoundary(node)) return false;
-		return ts$1.forEachChild(node, checkReturnStatements);
-	}
-	return ts$1.forEachChild(body, checkReturnStatements);
-}
-function checkForAwait(node) {
-	if (ts$1.isAwaitExpression(node)) return true;
-	if (ts$1.isForOfStatement(node) && node.awaitModifier) return true;
-	if (tsutils.isFunctionScopeBoundary(node)) return false;
-	return ts$1.forEachChild(node, checkForAwait);
-}
-function isEmptyBody(body) {
-	return ts$1.isBlock(body) && !body.statements.length;
-}
-//#endregion
-export { asyncFunctionAwaits_default as default };

package/lib/rules/asyncPromiseExecutors.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using async functions as Promise executor functions.";
-    readonly id: "asyncPromiseExecutors";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "asyncPromiseExecutor", undefined>;
-export default _default;