@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/exportFromImports.js

@@ -1,119 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/exportFromImports.ts
-function getImportInfo(node, sourceFile) {
-	if (!node.importClause) return;
-	const info = {
-		declaration: node,
-		moduleSpecifier: ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : node.moduleSpecifier.getText(sourceFile),
-		namedImports: /* @__PURE__ */ new Map()
-	};
-	const clause = node.importClause;
-	if (clause.name) info.defaultImport = clause.name.text;
-	if (clause.namedBindings) {
-		if (ts.isNamespaceImport(clause.namedBindings)) info.namespaceImport = clause.namedBindings.name.text;
-		else if (ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) {
-			const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-			const localName = element.name.text;
-			info.namedImports.set(localName, importedName);
-		}
-	}
-	return info;
-}
-var exportFromImports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports imports that are re-exported and could use export...from syntax instead.",
-		id: "exportFromImports",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferExportDefaultFrom: {
-			primary: "Prefer `export { default } from '{{ module }}'` instead of separate import and export default.",
-			secondary: ["When re-exporting a default export, you can use `export { default } from` syntax.", "This is more concise and makes the re-export intent clearer."],
-			suggestions: ["Use `export { default } from '{{ module }}'` syntax."]
-		},
-		preferExportFrom: {
-			primary: "Prefer `export { {{ name }} } from '{{ module }}'` instead of separate import and export.",
-			secondary: ["When re-exporting from a module, it's unnecessary to import and then export.", "Using `export...from` is more concise and makes the re-export intent clearer."],
-			suggestions: ["Use `export { {{ name }} } from '{{ module }}'` syntax."]
-		},
-		preferExportNamespaceFrom: {
-			primary: "Prefer `export * as {{ name }} from '{{ module }}'` instead of separate import and export.",
-			secondary: ["When re-exporting a namespace, you can use `export * as` syntax.", "This is more concise and makes the re-export intent clearer."],
-			suggestions: ["Use `export * as {{ name }} from '{{ module }}'` syntax."]
-		}
-	},
-	setup(context) {
-		return { visitors: { SourceFile: (node, { sourceFile }) => {
-			const imports = /* @__PURE__ */ new Map();
-			const exportAssignments = [];
-			const namedExports = [];
-			for (const statement of node.statements) switch (statement.kind) {
-				case ts.SyntaxKind.ExportAssignment:
-					if (!statement.isExportEquals) exportAssignments.push(statement);
-					break;
-				case ts.SyntaxKind.ExportDeclaration:
-					if (!statement.moduleSpecifier) namedExports.push(statement);
-					break;
-				case ts.SyntaxKind.ImportDeclaration: {
-					const info = getImportInfo(statement, sourceFile);
-					if (info) {
-						if (info.defaultImport) imports.set(info.defaultImport, info);
-						for (const [localName] of info.namedImports) imports.set(localName, info);
-						if (info.namespaceImport) imports.set(info.namespaceImport, info);
-					}
-					break;
-				}
-			}
-			for (const exportDeclaration of namedExports) {
-				if (!exportDeclaration.exportClause || !ts.isNamedExports(exportDeclaration.exportClause)) continue;
-				for (const element of exportDeclaration.exportClause.elements) {
-					const localName = element.propertyName ? element.propertyName.text : element.name.text;
-					const exportedName = element.name.text;
-					const importInfo = imports.get(localName);
-					if (!importInfo) continue;
-					if (importInfo.namedImports.has(localName)) context.report({
-						data: {
-							module: importInfo.moduleSpecifier,
-							name: exportedName
-						},
-						message: "preferExportFrom",
-						range: getTSNodeRange(element, sourceFile)
-					});
-					else if (importInfo.namespaceImport === localName) context.report({
-						data: {
-							module: importInfo.moduleSpecifier,
-							name: exportedName
-						},
-						message: "preferExportNamespaceFrom",
-						range: getTSNodeRange(element, sourceFile)
-					});
-					else if (importInfo.defaultImport === localName) context.report({
-						data: {
-							module: importInfo.moduleSpecifier,
-							name: exportedName
-						},
-						message: "preferExportFrom",
-						range: getTSNodeRange(element, sourceFile)
-					});
-				}
-			}
-			for (const exportAssignment of exportAssignments) {
-				if (!ts.isIdentifier(exportAssignment.expression)) continue;
-				const localName = exportAssignment.expression.text;
-				const importInfo = imports.get(localName);
-				if (importInfo?.defaultImport !== localName) continue;
-				context.report({
-					data: { module: importInfo.moduleSpecifier },
-					message: "preferExportDefaultFrom",
-					range: getTSNodeRange(exportAssignment, sourceFile)
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { exportFromImports_default as default };
-
-//# sourceMappingURL=exportFromImports.js.map

package/lib/rules/exportMutables.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports exporting mutable bindings (let or var).";
-    readonly id: "exportMutables";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noMutableExport", undefined>;
-export default _default;
-//# sourceMappingURL=exportMutables.d.ts.map

package/lib/rules/exportMutables.js

@@ -1,33 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/exportMutables.ts
-function isMutableDeclaration(node) {
-	return (node.flags & ts.NodeFlags.Let) !== 0 || (node.flags & ts.NodeFlags.Const) === 0;
-}
-var exportMutables_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports exporting mutable bindings (let or var).",
-		id: "exportMutables",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noMutableExport: {
-		primary: "Exported variable '{{ name }}' is mutable. Use const instead.",
-		secondary: ["Mutable exports can lead to confusing behavior when the value is changed after import.", "Consumers of the module may not expect the exported value to change."],
-		suggestions: ["Use const to declare the exported variable.", "If mutation is necessary, export a getter function instead."]
-	} },
-	setup(context) {
-		return { visitors: { VariableStatement: (node, { sourceFile }) => {
-			if (!isMutableDeclaration(node.declarationList) || !node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)) return;
-			for (const declaration of node.declarationList.declarations) context.report({
-				data: { name: declaration.name.kind === SyntaxKind.Identifier ? declaration.name.text : declaration.name.getText(sourceFile) },
-				message: "noMutableExport",
-				range: getTSNodeRange(declaration.name, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { exportMutables_default as default };
-
-//# sourceMappingURL=exportMutables.js.map

package/lib/rules/exportUniqueNames.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports duplicate export names in a module.";
-    readonly id: "exportUniqueNames";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateExport", undefined>;
-export default _default;
-//# sourceMappingURL=exportUniqueNames.d.ts.map

package/lib/rules/exportUniqueNames.js

@@ -1,65 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/exportUniqueNames.ts
-function hasDefaultModifier(modifiers) {
-	return modifiers?.some((mod) => mod.kind === SyntaxKind.DefaultKeyword);
-}
-function hasExportModifier(modifiers) {
-	return modifiers?.some((mod) => mod.kind === SyntaxKind.ExportKeyword);
-}
-var exportUniqueNames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports duplicate export names in a module.",
-		id: "exportUniqueNames",
-		presets: ["javascript"]
-	},
-	messages: { duplicateExport: {
-		primary: "Duplicate export '{{ name }}' found.",
-		secondary: ["Having multiple exports with the same name creates ambiguity about which value is exported."],
-		suggestions: ["Remove or rename one of the duplicate exports."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile: (node, { sourceFile }) => {
-			const exportedNames = /* @__PURE__ */ new Map();
-			function checkAndReportDuplicate(name, node) {
-				if (exportedNames.get(name)) context.report({
-					data: { name },
-					message: "duplicateExport",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				else exportedNames.set(name, node);
-			}
-			function checkClassOrFunctionDeclaration(statement) {
-				if (hasExportModifier(statement.modifiers) && !hasDefaultModifier(statement.modifiers) && statement.name) checkAndReportDuplicate(statement.name.text, statement.name);
-			}
-			function checkExportDeclaration(statement) {
-				if (statement.exportClause && ts.isNamedExports(statement.exportClause) && !statement.isTypeOnly) for (const specifier of statement.exportClause.elements) {
-					if (specifier.isTypeOnly) continue;
-					const exportedName = specifier.name.text;
-					checkAndReportDuplicate(exportedName, specifier.name);
-				}
-			}
-			function checkVariableStatement(statement) {
-				if (!hasExportModifier(statement.modifiers)) return;
-				for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) checkAndReportDuplicate(declaration.name.text, declaration.name);
-			}
-			for (const statement of node.statements) switch (statement.kind) {
-				case SyntaxKind.ClassDeclaration:
-				case SyntaxKind.FunctionDeclaration:
-					checkClassOrFunctionDeclaration(statement);
-					break;
-				case SyntaxKind.ExportDeclaration:
-					checkExportDeclaration(statement);
-					break;
-				case SyntaxKind.VariableStatement:
-					checkVariableStatement(statement);
-					break;
-			}
-		} } };
-	}
-});
-//#endregion
-export { exportUniqueNames_default as default };
-
-//# sourceMappingURL=exportUniqueNames.js.map

package/lib/rules/extraneousClasses.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports classes used as static namespaces.";
-    readonly id: "extraneousClasses";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "empty" | "onlyConstructor" | "onlyStatic", {
-    allowConstructorOnly: z.ZodDefault<z.ZodBoolean>;
-    allowEmpty: z.ZodDefault<z.ZodBoolean>;
-    allowStaticOnly: z.ZodDefault<z.ZodBoolean>;
-    allowWithDecorator: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;
-//# sourceMappingURL=extraneousClasses.d.ts.map

package/lib/rules/extraneousClasses.js

@@ -1,111 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z } from "zod/v4";
-//#region src/rules/extraneousClasses.ts
-function hasDecorators(node) {
-	return node.modifiers?.some(ts.isDecorator) ?? false;
-}
-function hasParameterProperties(constructor) {
-	return constructor.parameters.some((parameter) => parameter.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword || modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword || modifier.kind === ts.SyntaxKind.ReadonlyKeyword));
-}
-function hasStaticModifier(modifiers) {
-	return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ?? false;
-}
-function hasSuperClass(node) {
-	return node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? false;
-}
-function isRealMember(member) {
-	return !ts.isConstructorDeclaration(member) && !ts.isClassStaticBlockDeclaration(member) && !ts.isSemicolonClassElement(member);
-}
-const options = {
-	allowConstructorOnly: z.boolean().default(false).describe("Whether to allow extraneous classes that contain only a constructor."),
-	allowEmpty: z.boolean().default(false).describe("Whether to allow extraneous classes that have no body (are empty)."),
-	allowStaticOnly: z.boolean().default(false).describe("Whether to allow extraneous classes that only contain static members."),
-	allowWithDecorator: z.boolean().default(false).describe("Whether to allow extraneous classes that include a decorator.")
-};
-var extraneousClasses_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports classes used as static namespaces.",
-		id: "extraneousClasses",
-		presets: ["logicalStrict"]
-	},
-	messages: {
-		empty: {
-			primary: "This empty class does nothing and can be removed.",
-			secondary: ["Empty classes serve no purpose and add unnecessary noise to the codebase."],
-			suggestions: ["Remove the empty class.", "Add members if you intended the class to have functionality."]
-		},
-		onlyConstructor: {
-			primary: "This class contains only a constructor and can be removed or replaced with a standalone function.",
-			secondary: ["Classes with only a constructor and no fields can be replaced with a standalone function."],
-			suggestions: ["Replace the class with a standalone function.", "Add instance properties or methods if the class needs state."]
-		},
-		onlyStatic: {
-			primary: "This class contains only static properties and can be removed or replaced with variables.",
-			secondary: ["Static-only classes can be replaced with plain objects or module exports.", "Using a class as a namespace adds unnecessary complexity."],
-			suggestions: ["Convert static methods to standalone exported functions.", "Use 'export * as namespace' to group exports if needed."]
-		}
-	},
-	options,
-	setup(context) {
-		function checkClass(node, { options, sourceFile }) {
-			if (hasSuperClass(node)) return;
-			if (options.allowWithDecorator && hasDecorators(node)) return;
-			const realMembers = node.members.filter(isRealMember);
-			const reportRange = node.name ? {
-				begin: node.name.getStart(sourceFile),
-				end: node.name.getEnd()
-			} : {
-				begin: node.getStart(sourceFile),
-				end: node.getEnd()
-			};
-			if (!realMembers.length) {
-				for (const member of node.members) if (ts.isConstructorDeclaration(member) && hasParameterProperties(member)) return;
-				if (node.members.some(ts.isConstructorDeclaration)) {
-					if (!options.allowConstructorOnly) context.report({
-						message: "onlyConstructor",
-						range: reportRange
-					});
-				} else if (!options.allowEmpty) context.report({
-					message: "empty",
-					range: reportRange
-				});
-				return;
-			}
-			let onlyStatic = true;
-			let onlyConstructor = true;
-			for (const member of node.members) {
-				if (ts.isConstructorDeclaration(member)) {
-					if (hasParameterProperties(member)) {
-						onlyConstructor = false;
-						onlyStatic = false;
-					}
-				} else if (isRealMember(member)) {
-					onlyConstructor = false;
-					if (!hasStaticModifier(member.modifiers)) onlyStatic = false;
-				}
-				if (!onlyConstructor && !onlyStatic) break;
-			}
-			if (onlyConstructor) {
-				if (!options.allowConstructorOnly) context.report({
-					message: "onlyConstructor",
-					range: reportRange
-				});
-				return;
-			}
-			if (onlyStatic && !options.allowStaticOnly) context.report({
-				message: "onlyStatic",
-				range: reportRange
-			});
-		}
-		return { visitors: {
-			ClassDeclaration: checkClass,
-			ClassExpression: checkClass
-		} };
-	}
-});
-//#endregion
-export { extraneousClasses_default as default };
-
-//# sourceMappingURL=extraneousClasses.js.map

package/lib/rules/fetchMethodBodies.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallow providing a body with GET or HEAD fetch requests.";
-    readonly id: "fetchMethodBodies";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noBody", undefined>;
-export default _default;
-//# sourceMappingURL=fetchMethodBodies.d.ts.map

package/lib/rules/fetchMethodBodies.js

@@ -1,72 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/fetchMethodBodies.ts
-var fetchMethodBodies_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow providing a body with GET or HEAD fetch requests.",
-		id: "fetchMethodBodies",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noBody: {
-		primary: "`body` is not allowed when the request method is `{{ method }}`.",
-		secondary: ["The Fetch API will throw a `TypeError` at runtime if a body is provided with a `{{ method }}` request."],
-		suggestions: ["Remove the `body` property from the options.", "Change the method to `POST`, `PUT`, or another method that supports request bodies."]
-	} },
-	setup(context) {
-		function isUndefinedOrNull(node) {
-			return node.kind === SyntaxKind.Identifier && node.text === "undefined" || node.kind === SyntaxKind.NullKeyword;
-		}
-		function collectFetchOptions(node) {
-			let bodyName;
-			let methodText;
-			for (const property of node.properties) switch (property.kind) {
-				case SyntaxKind.PropertyAssignment:
-					if (property.name.kind !== SyntaxKind.Identifier) return;
-					switch (property.name.text) {
-						case "body":
-							if (isUndefinedOrNull(property.initializer)) return;
-							bodyName = property.name;
-							break;
-						case "method":
-							if (property.initializer.kind !== SyntaxKind.StringLiteral) return;
-							methodText = property.initializer.text;
-							break;
-					}
-					break;
-				case SyntaxKind.SpreadAssignment: return;
-			}
-			return {
-				bodyName,
-				methodText
-			};
-		}
-		function checkFetchOptions(node, sourceFile) {
-			if (node.kind !== SyntaxKind.ObjectLiteralExpression) return;
-			const collected = collectFetchOptions(node);
-			if (!collected?.bodyName) return;
-			const method = collected.methodText?.toUpperCase() ?? "GET";
-			if (!["GET", "HEAD"].includes(method)) return;
-			context.report({
-				data: { method },
-				message: "noBody",
-				range: getTSNodeRange(collected.bodyName, sourceFile)
-			});
-		}
-		function checkNode(node, functionName, sourceFile) {
-			if (node.expression.kind === SyntaxKind.Identifier && node.expression.text === functionName && node.arguments && node.arguments.length >= 2) checkFetchOptions(node.arguments[1], sourceFile);
-		}
-		return { visitors: {
-			CallExpression: (node, { sourceFile }) => {
-				checkNode(node, "fetch", sourceFile);
-			},
-			NewExpression: (node, { sourceFile }) => {
-				checkNode(node, "Request", sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { fetchMethodBodies_default as default };
-
-//# sourceMappingURL=fetchMethodBodies.js.map

package/lib/rules/finallyStatementSafety.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.";
-    readonly id: "finallyStatementSafety";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unsafeFinally", undefined>;
-export default _default;
-//# sourceMappingURL=finallyStatementSafety.d.ts.map

package/lib/rules/finallyStatementSafety.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/finallyStatementSafety.ts
-var finallyStatementSafety_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.",
-		id: "finallyStatementSafety",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unsafeFinally: {
-		primary: "Control flow statements in `finally` blocks misleadingly override control flow from `try`/`catch` blocks.",
-		secondary: ["Control flow statements like `break`, `continue`, `return`, and `throw` in finally blocks can override control flow statements in the try or catch blocks.", "This can lead to unexpected behavior, as the `finally` block will execute regardless of what happens in `try`/`catch`, and its control flow takes precedence."],
-		suggestions: ["Move the control flow statement out of the `finally` block.", "Remove the control flow statement if the `finally` block is only used for cleanup operations."]
-	} },
-	setup(context) {
-		return { visitors: { TryStatement: (node, { sourceFile }) => {
-			if (!node.finallyBlock) return;
-			function checkStatement(statement) {
-				if (statement.kind === SyntaxKind.ReturnStatement || statement.kind === SyntaxKind.ThrowStatement || statement.kind === SyntaxKind.BreakStatement || statement.kind === SyntaxKind.ContinueStatement) {
-					const firstToken = statement.getFirstToken(sourceFile);
-					if (!firstToken) return;
-					context.report({
-						message: "unsafeFinally",
-						range: {
-							begin: statement.getStart(sourceFile),
-							end: statement.getStart(sourceFile) + firstToken.getText().length
-						}
-					});
-				}
-				if (statement.kind === SyntaxKind.Block) statement.statements.forEach(checkStatement);
-				else if (statement.kind === SyntaxKind.IfStatement) {
-					checkStatement(statement.thenStatement);
-					if (statement.elseStatement) checkStatement(statement.elseStatement);
-				} else if (statement.kind === SyntaxKind.SwitchStatement) statement.caseBlock.clauses.forEach((clause) => {
-					clause.statements.forEach(checkStatement);
-				});
-				else if (statement.kind === SyntaxKind.LabeledStatement) checkStatement(statement.statement);
-			}
-			checkStatement(node.finallyBlock);
-		} } };
-	}
-});
-//#endregion
-export { finallyStatementSafety_default as default };
-
-//# sourceMappingURL=finallyStatementSafety.js.map

package/lib/rules/forDirections.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports for loops with counter variables that move in the wrong direction.";
-    readonly id: "forDirections";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "wrongDirection", undefined>;
-export default _default;
-//# sourceMappingURL=forDirections.d.ts.map

package/lib/rules/forDirections.js

@@ -1,75 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/forDirections.ts
-function getConditionDirection(condition, counterName) {
-	if (condition.kind !== SyntaxKind.BinaryExpression) return;
-	const leftName = getCounterName(condition.left);
-	const rightName = getCounterName(condition.right);
-	if (!leftName && !rightName) return condition.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken ? getConditionDirection(condition.left, counterName) ?? getConditionDirection(condition.right, counterName) : void 0;
-	const isCounterLeft = leftName === counterName;
-	if (!isCounterLeft && !(rightName === counterName)) return;
-	const { operatorToken } = condition;
-	if (isCounterLeft) {
-		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return 1;
-		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return -1;
-	} else {
-		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return -1;
-		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return 1;
-	}
-}
-function getCounterName(node) {
-	return node.kind === SyntaxKind.Identifier ? node.text : void 0;
-}
-function getIncrementorDirection(incrementor) {
-	if (incrementor.kind === SyntaxKind.PostfixUnaryExpression || incrementor.kind === SyntaxKind.PrefixUnaryExpression) switch (incrementor.operator) {
-		case SyntaxKind.MinusMinusToken: return -1;
-		case SyntaxKind.PlusPlusToken: return 1;
-		default: return;
-	}
-	if (incrementor.kind === SyntaxKind.BinaryExpression) {
-		const { operatorToken, right } = incrementor;
-		if (operatorToken.kind === SyntaxKind.PlusEqualsToken || operatorToken.kind === SyntaxKind.MinusEqualsToken) {
-			if (right.kind === SyntaxKind.NumericLiteral) {
-				const value = Number(right.text);
-				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? 1 : value < 0 ? -1 : 0;
-				return value > 0 ? -1 : value < 0 ? 1 : 0;
-			}
-			if (right.kind === SyntaxKind.PrefixUnaryExpression && right.operator === SyntaxKind.MinusToken && right.operand.kind === SyntaxKind.NumericLiteral) {
-				const value = Number(right.operand.text);
-				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? -1 : 1;
-				return value > 0 ? 1 : -1;
-			}
-		}
-	}
-}
-var forDirections_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports for loops with counter variables that move in the wrong direction.",
-		id: "forDirections",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { wrongDirection: {
-		primary: "The update moves the counter in the wrong direction for this loop condition.",
-		secondary: ["A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.", "When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect."],
-		suggestions: ["Verify the loop counter update direction matches the condition."]
-	} },
-	setup(context) {
-		return { visitors: { ForStatement: (node, { sourceFile }) => {
-			if (!node.condition || !node.incrementor || node.initializer?.kind !== SyntaxKind.VariableDeclarationList) return;
-			const declaration = node.initializer.declarations.at(0);
-			if (declaration?.name.kind !== SyntaxKind.Identifier) return;
-			const updateDirection = getIncrementorDirection(node.incrementor);
-			if (!updateDirection) return;
-			const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
-			if (conditionDirection && conditionDirection !== updateDirection) context.report({
-				message: "wrongDirection",
-				range: getTSNodeRange(node.incrementor, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { forDirections_default as default };
-
-//# sourceMappingURL=forDirections.js.map

package/lib/rules/forInArrays.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports iterating over an array with a for-in loop.";
-    readonly id: "forInArrays";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "forIn", undefined>;
-export default _default;
-//# sourceMappingURL=forInArrays.d.ts.map

package/lib/rules/forInArrays.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { isTypeRecursive } from "./utils/isTypeRecursive.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/forInArrays.ts
-var forInArrays_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports iterating over an array with a for-in loop.",
-		id: "forInArrays",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { forIn: {
-		primary: "For-in loops over arrays have surprising behavior that often leads to bugs.",
-		secondary: [
-			"A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
-			"This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
-			"It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices."
-		],
-		suggestions: ["Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`)."]
-	} },
-	setup(context) {
-		function hasNumberLikeLength(type, typeChecker) {
-			const lengthProperty = type.getProperty("length");
-			if (lengthProperty == null) return false;
-			return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
-		}
-		function isArrayLike(type, typeChecker) {
-			return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
-		}
-		return { visitors: { ForInStatement: (node, { sourceFile, typeChecker }) => {
-			if (isArrayLike(getConstrainedTypeAtLocation(node.expression, typeChecker), typeChecker)) context.report({
-				message: "forIn",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.statement.getStart(sourceFile) - 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { forInArrays_default as default };
-
-//# sourceMappingURL=forInArrays.js.map