@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/exceptionAssignments.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/exceptionAssignments.ts
-var exceptionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports reassigning exception parameters in catch clauses.",
-		id: "exceptionAssignments",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noExAssign: {
-		primary: "Exception parameters in catch clauses should not be reassigned.",
-		secondary: ["Reassigning an exception parameter can make debugging more difficult by obscuring the original error.", "The exception parameter contains important information about what went wrong, and reassigning it can make it harder to understand the root cause of an error."],
-		suggestions: ["Use a different variable name for the new value instead of reassigning the exception parameter."]
-	} },
-	setup(context) {
-		function collectBindingElements(name) {
-			const identifiers = [];
-			if (name.kind === SyntaxKind.Identifier) identifiers.push(name);
-			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
-			return identifiers;
-		}
-		return { visitors: { CatchClause: (node, { sourceFile }) => {
-			if (!node.variableDeclaration?.name) return;
-			const identifiers = collectBindingElements(node.variableDeclaration.name);
-			for (const identifier of identifiers) {
-				const modifyingReferences = getModifyingReferences(identifier, sourceFile);
-				for (const reference of modifyingReferences) context.report({
-					message: "noExAssign",
-					range: getTSNodeRange(reference, sourceFile)
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { exceptionAssignments_default as default };

package/lib/rules/explicitAnys.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports explicit uses of the any type.";
-    readonly id: "explicitAnys";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noExplicitAny", undefined>;
-export default _default;

package/lib/rules/explicitAnys.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/explicitAnys.ts
-function isNodeWithinKeyofAny(node) {
-	return node.parent.kind === ts.SyntaxKind.TypeOperator && node.parent.operator === ts.SyntaxKind.KeyOfKeyword;
-}
-var explicitAnys_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports explicit uses of the any type.",
-		id: "explicitAnys",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noExplicitAny: {
-		primary: "Avoid using the `any` type as it disables type checking for the annotated value.",
-		secondary: [
-			"Using `any` eliminates many of the benefits of TypeScript's type system.",
-			"It allows `any` operation on the value without compile-time checks.",
-			"Errors that could be caught at compile time may only appear at runtime."
-		],
-		suggestions: [
-			"Use `unknown` instead if you need to accept `any` value but want type safety.",
-			"Use a more specific type if the possible values are known.",
-			"For generic classes and functions, use type parameters to preserve type information across calls.",
-			"For keyof `any`, consider using `PropertyKey` instead."
-		]
-	} },
-	setup(context) {
-		return { visitors: { AnyKeyword: (node, { sourceFile }) => {
-			const isKeyofAny = isNodeWithinKeyofAny(node);
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				message: "noExplicitAny",
-				range,
-				suggestions: isKeyofAny ? [{
-					id: "propertyKey",
-					range: getTSNodeRange(node.parent, sourceFile),
-					text: "PropertyKey"
-				}] : [{
-					id: "unknown",
-					range,
-					text: "unknown"
-				}, {
-					id: "never",
-					range,
-					text: "never"
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { explicitAnys_default as default };

package/lib/rules/exponentiationOperators.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefers the ** operator over Math.pow().";
-    readonly id: "exponentiationOperators";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferOperator", undefined>;
-export default _default;

package/lib/rules/exponentiationOperators.js

@@ -1,32 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/exponentiationOperators.ts
-var exponentiationOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefers the ** operator over Math.pow().",
-		id: "exponentiationOperators",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferOperator: {
-		primary: "Prefer the more succinct `**` operator instead of Math.pow() for exponentiation.",
-		secondary: ["The `**` operator was introduced in ES2016 and is more readable.", "It also works with BigInt values, unlike Math.pow()."],
-		suggestions: ["`Replace Math.pow(base, exponent)` with `**`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "pow" || node.expression.expression.kind !== SyntaxKind.Identifier || node.expression.expression.text !== "Math" || node.arguments.length !== 2 || !isGlobalDeclarationOfName(node.expression.expression, "Math", typeChecker, program)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: node.arguments.map((argument) => argument.getText(sourceFile)).join(" ** ")
-				},
-				message: "preferOperator",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { exponentiationOperators_default as default };

package/lib/rules/exportFromImports.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports imports that are re-exported and could use export...from syntax instead.";
-    readonly id: "exportFromImports";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferExportDefaultFrom" | "preferExportFrom" | "preferExportNamespaceFrom", undefined>;
-export default _default;

package/lib/rules/exportFromImports.js

@@ -1,117 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticStringValue, 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: getStaticStringValue(node.moduleSpecifier) ?? 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 };

package/lib/rules/exportMutables.d.ts

@@ -1,9 +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;

package/lib/rules/exportMutables.js

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

package/lib/rules/exportUniqueNames.d.ts

@@ -1,9 +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;

package/lib/rules/exportUniqueNames.js

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

package/lib/rules/extraneousClasses.d.ts

@@ -1,15 +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;

package/lib/rules/extraneousClasses.js

@@ -1,109 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z as z$1 } 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$1.boolean().default(false).describe("Whether to allow extraneous classes that contain only a constructor."),
-	allowEmpty: z$1.boolean().default(false).describe("Whether to allow extraneous classes that have no body (are empty)."),
-	allowStaticOnly: z$1.boolean().default(false).describe("Whether to allow extraneous classes that only contain static members."),
-	allowWithDecorator: z$1.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 };

package/lib/rules/fetchMethodBodies.d.ts

@@ -1,9 +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;

package/lib/rules/fetchMethodBodies.js

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

package/lib/rules/finallyStatementSafety.d.ts

@@ -1,9 +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;

package/lib/rules/finallyStatementSafety.js

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

package/lib/rules/forDirections.d.ts

@@ -1,9 +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;