@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/exportFromImports.js

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

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

package/lib/rules/exportMutables.js

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

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

package/lib/rules/exportUniqueNames.js

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

@@ -0,0 +1,16 @@
+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: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "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

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

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

package/lib/rules/fetchMethodBodies.js

@@ -0,0 +1,72 @@
+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,7 +1,10 @@
 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 preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unsafeFinally", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unsafeFinally", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=finallyStatementSafety.d.ts.map

package/lib/rules/finallyStatementSafety.js

@@ -1,71 +1,47 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.",
-        id: "finallyStatementSafety",
-        preset: "logical",
-    },
-    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) => {
-                    if (!node.finallyBlock) {
-                        return;
-                    }
-                    function checkStatement(statement) {
-                        if (ts.isReturnStatement(statement) ||
-                            ts.isThrowStatement(statement) ||
-                            ts.isBreakStatement(statement) ||
-                            ts.isContinueStatement(statement)) {
-                            const firstToken = statement.getFirstToken(context.sourceFile);
-                            if (!firstToken) {
-                                return;
-                            }
-                            context.report({
-                                message: "unsafeFinally",
-                                range: {
-                                    begin: statement.getStart(context.sourceFile),
-                                    end: statement.getStart(context.sourceFile) +
-                                        firstToken.getText().length,
-                                },
-                            });
-                        }
-                        if (ts.isBlock(statement)) {
-                            statement.statements.forEach(checkStatement);
-                        }
-                        else if (ts.isIfStatement(statement)) {
-                            checkStatement(statement.thenStatement);
-                            if (statement.elseStatement) {
-                                checkStatement(statement.elseStatement);
-                            }
-                        }
-                        else if (ts.isSwitchStatement(statement)) {
-                            statement.caseBlock.clauses.forEach((clause) => {
-                                clause.statements.forEach(checkStatement);
-                            });
-                        }
-                        else if (ts.isLabeledStatement(statement)) {
-                            checkStatement(statement.statement);
-                        }
-                    }
-                    checkStatement(node.finallyBlock);
-                },
-            },
-        };
-    },
+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,7 +1,10 @@
 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 preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "wrongDirection", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "wrongDirection", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=forDirections.d.ts.map