@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/duplicateArguments.js

@@ -1,45 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/duplicateArguments.ts
-var duplicateArguments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports functions with duplicate parameter names in their signatures.",
-		id: "duplicateArguments",
-		presets: ["javascript"]
-	},
-	messages: { duplicateParam: {
-		primary: "This parameter overrides the previous parameter of the same name.",
-		secondary: [
-			"Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
-			"In strict mode, duplicate parameter names are a syntax error.",
-			"Even in non-strict mode, only the last parameter with a given name is accessible."
-		],
-		suggestions: ["Rename one of the duplicate parameters to a unique name."]
-	} },
-	setup(context) {
-		function checkNode({ parameters }, { sourceFile }) {
-			const seenNames = /* @__PURE__ */ new Set();
-			for (const parameter of parameters) {
-				if (parameter.name.kind !== SyntaxKind.Identifier) continue;
-				const parameterName = parameter.name.text;
-				if (seenNames.has(parameterName)) context.report({
-					message: "duplicateParam",
-					range: getTSNodeRange(parameter.name, sourceFile)
-				});
-				else seenNames.add(parameterName);
-			}
-		}
-		return { visitors: {
-			ArrowFunction: checkNode,
-			Constructor: checkNode,
-			FunctionDeclaration: checkNode,
-			FunctionExpression: checkNode,
-			MethodDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { duplicateArguments_default as default };
-
-//# sourceMappingURL=duplicateArguments.js.map

package/lib/rules/dynamicDeletes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallow using the delete operator on computed key expressions.";
-    readonly id: "dynamicDeletes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "dynamicDelete", undefined>;
-export default _default;
-//# sourceMappingURL=dynamicDeletes.d.ts.map

package/lib/rules/dynamicDeletes.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind, isElementAccessExpression, isNumericLiteral, isPrefixUnaryExpression, isStringLiteral } from "typescript";
-//#region src/rules/dynamicDeletes.ts
-function isAcceptableIndexExpression(property) {
-	return isStringLiteral(property) || isNumericLiteral(property) || isPrefixUnaryExpression(property) && property.operator === SyntaxKind.MinusToken && isNumericLiteral(property.operand);
-}
-var dynamicDeletes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow using the delete operator on computed key expressions.",
-		id: "dynamicDeletes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { dynamicDelete: {
-		primary: "Using the `delete` operator on a computed key can be dangerous and is often not well optimized.",
-		secondary: ["In modern code, JavaScript objects are generally intended to be optimized as static shapes by engines.", "Consider using a `Map` or `Set` if you need to dynamically add and remove keys."],
-		suggestions: ["Use a `Map` or `Set` instead of an object for dynamic keys."]
-	} },
-	setup(context) {
-		return { visitors: { DeleteExpression: (node, { sourceFile }) => {
-			const argument = node.expression;
-			if (!isElementAccessExpression(argument) || isAcceptableIndexExpression(argument.argumentExpression)) return;
-			const property = argument.argumentExpression;
-			context.report({
-				message: "dynamicDelete",
-				range: {
-					begin: property.getStart(sourceFile),
-					end: property.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { dynamicDeletes_default as default };
-
-//# sourceMappingURL=dynamicDeletes.js.map

package/lib/rules/elseIfDuplicates.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
-    readonly id: "elseIfDuplicates";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateCondition", undefined>;
-export default _default;
-//# sourceMappingURL=elseIfDuplicates.d.ts.map

package/lib/rules/elseIfDuplicates.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/elseIfDuplicates.ts
-var elseIfDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports duplicate conditions in if-else-if chains that make code unreachable.",
-		id: "elseIfDuplicates",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { duplicateCondition: {
-		primary: "This condition is identical to a previous condition in the if-else-if chain.",
-		secondary: ["When an if-else-if chain has duplicate conditions, the duplicate branch will never execute because the earlier identical condition will always be evaluated first.", "This typically indicates a copy-paste error or logic mistake."],
-		suggestions: ["Verify the condition logic is correct and update to check for the intended condition."]
-	} },
-	setup(context) {
-		function checkIfStatement(node, sourceFile) {
-			const seen = [];
-			let current = node;
-			while (true) {
-				if (seen.some((previous) => hasSameTokens(previous, current.expression, sourceFile))) context.report({
-					message: "duplicateCondition",
-					range: getTSNodeRange(current.expression, sourceFile)
-				});
-				if (current.elseStatement?.kind !== SyntaxKind.IfStatement) break;
-				seen.push(current.expression);
-				current = current.elseStatement;
-			}
-		}
-		return { visitors: { IfStatement: (node, { sourceFile }) => {
-			if (node.parent.kind !== SyntaxKind.IfStatement || node.parent.elseStatement !== node) checkIfStatement(node, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { elseIfDuplicates_default as default };
-
-//# sourceMappingURL=elseIfDuplicates.js.map

package/lib/rules/elseReturns.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary `else` blocks following `if` statements that always return or throw.";
-    readonly id: "elseReturns";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryElse", undefined>;
-export default _default;
-//# sourceMappingURL=elseReturns.d.ts.map

package/lib/rules/elseReturns.js

@@ -1,67 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/elseReturns.ts
-function alwaysTerminates(node) {
-	switch (node.kind) {
-		case SyntaxKind.Block: return node.statements.some((statement) => isTerminatingStatement(statement.kind) || hasNestedIfThatTerminates(statement));
-		case SyntaxKind.ReturnStatement:
-		case SyntaxKind.ThrowStatement: return true;
-		default: return hasNestedIfThatTerminates(node);
-	}
-}
-function findElseKeyword(node, sourceFile) {
-	return node.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ElseKeyword);
-}
-function hasNestedIfThatTerminates(node) {
-	return node.kind === SyntaxKind.IfStatement && node.elseStatement !== void 0 && naiveTerminates(node.thenStatement) && naiveTerminates(node.elseStatement);
-}
-function isInStatementListContext(node) {
-	return node.parent.kind === SyntaxKind.Block || node.parent.kind === SyntaxKind.SourceFile || node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.CaseClause || node.parent.kind === SyntaxKind.DefaultClause;
-}
-function isTerminatingStatement(kind) {
-	return kind === SyntaxKind.ReturnStatement || kind === SyntaxKind.ThrowStatement;
-}
-function naiveTerminates(node) {
-	if (node.kind !== SyntaxKind.Block) return isTerminatingStatement(node.kind);
-	const lastStatement = node.statements.at(-1);
-	if (!lastStatement) return false;
-	return isTerminatingStatement(lastStatement.kind) || hasNestedIfThatTerminates(lastStatement);
-}
-var elseReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary `else` blocks following `if` statements that always return or throw.",
-		id: "elseReturns",
-		presets: ["stylisticStrict"]
-	},
-	messages: { unnecessaryElse: {
-		primary: "This `else` clause is unnecessary after a terminating statement.",
-		secondary: ["When an `if` block always returns or throws, the `else` block is redundant because the code after the `if` statement will only execute when the condition is false."],
-		suggestions: ["Remove the `else` keyword and un-indent the contents of the `else` block."]
-	} },
-	setup(context) {
-		return { visitors: { IfStatement: (node, { sourceFile }) => {
-			if (!isInStatementListContext(node) || !node.elseStatement) return;
-			const thenBranches = [];
-			let lastIfNode = node;
-			let currentNode = node;
-			while (currentNode.kind === SyntaxKind.IfStatement) {
-				if (!currentNode.elseStatement) return;
-				thenBranches.push(currentNode.thenStatement);
-				lastIfNode = currentNode;
-				currentNode = currentNode.elseStatement;
-			}
-			if (!thenBranches.every(alwaysTerminates)) return;
-			const elseKeyword = findElseKeyword(lastIfNode, sourceFile);
-			if (!elseKeyword) return;
-			context.report({
-				message: "unnecessaryElse",
-				range: getTSNodeRange(elseKeyword, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { elseReturns_default as default };
-
-//# sourceMappingURL=elseReturns.js.map

package/lib/rules/emptyBlocks.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty block statements that should contain code.";
-    readonly id: "emptyBlocks";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyBlock", undefined>;
-export default _default;
-//# sourceMappingURL=emptyBlocks.d.ts.map

package/lib/rules/emptyBlocks.js

@@ -1,56 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyBlocks.ts
-const allowedParents = new Set([
-	SyntaxKind.ArrowFunction,
-	SyntaxKind.CatchClause,
-	SyntaxKind.Constructor,
-	SyntaxKind.FunctionDeclaration,
-	SyntaxKind.FunctionExpression,
-	SyntaxKind.GetAccessor,
-	SyntaxKind.MethodDeclaration,
-	SyntaxKind.SetAccessor
-]);
-var emptyBlocks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty block statements that should contain code.",
-		id: "emptyBlocks",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyBlock: {
-		primary: "Empty block statements should be removed or contain code.",
-		secondary: ["Empty blocks can indicate incomplete code or areas where logic was removed but the block structure was left behind.", "They can also reduce code readability by cluttering the codebase with unnecessary braces."],
-		suggestions: ["Add a comment explaining why the block is intentionally empty, or remove the empty block entirely."]
-	} },
-	setup(context) {
-		function hasComments(block, sourceFile) {
-			const fullText = sourceFile.getFullText();
-			const openBrace = block.getStart(sourceFile);
-			const closeBrace = block.getEnd();
-			const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
-			return /\S+/.test(innerText.trim());
-		}
-		function isEmptyBlock(block, sourceFile) {
-			return !block.statements.length && !hasComments(block, sourceFile);
-		}
-		return { visitors: {
-			Block: (node, { sourceFile }) => {
-				if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node, sourceFile)) context.report({
-					message: "emptyBlock",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			CaseBlock: (node, { sourceFile }) => {
-				if (!node.clauses.length) context.report({
-					message: "emptyBlock",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyBlocks_default as default };
-
-//# sourceMappingURL=emptyBlocks.js.map

package/lib/rules/emptyDestructures.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using empty destructuring patterns that destructure no values.";
-    readonly id: "emptyDestructures";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyPattern", undefined>;
-export default _default;
-//# sourceMappingURL=emptyDestructures.d.ts.map

package/lib/rules/emptyDestructures.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyDestructures.ts
-var emptyDestructures_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using empty destructuring patterns that destructure no values.",
-		id: "emptyDestructures",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { emptyPattern: {
-		primary: "Destructuring patterns that don't extract at least one value are unnecessary.",
-		secondary: ["Empty destructuring patterns like `{}` or `[]` don't extract any values and serve no practical purpose.", "These patterns are likely mistakes or leftover code from refactoring."],
-		suggestions: ["Remove the empty destructuring pattern if it's not needed.", "Add bindings to extract values if you intended to destructure specific properties."]
-	} },
-	setup(context) {
-		function checkBindingPattern(node, { sourceFile }) {
-			if (!node.elements.length) context.report({
-				message: "emptyPattern",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		}
-		return { visitors: {
-			ArrayBindingPattern: checkBindingPattern,
-			ObjectBindingPattern: checkBindingPattern
-		} };
-	}
-});
-//#endregion
-export { emptyDestructures_default as default };
-
-//# sourceMappingURL=emptyDestructures.js.map

package/lib/rules/emptyEnums.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty enum declarations with no members.";
-    readonly id: "emptyEnums";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyEnum", undefined>;
-export default _default;
-//# sourceMappingURL=emptyEnums.d.ts.map

package/lib/rules/emptyEnums.js

@@ -1,30 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyEnums.ts
-var emptyEnums_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty enum declarations with no members.",
-		id: "emptyEnums",
-		presets: ["logical"]
-	},
-	messages: { emptyEnum: {
-		primary: "Empty enums serve no purpose.",
-		secondary: ["An enum with no members cannot be used to represent any values.", "Empty enums are typically the result of incomplete implementation or mistaken deletion."],
-		suggestions: ["Add members to the enum to define valid values.", "Remove the empty enum if it is no longer needed."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
-			if (!node.members.length) context.report({
-				message: "emptyEnum",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { emptyEnums_default as default };
-
-//# sourceMappingURL=emptyEnums.js.map

package/lib/rules/emptyExports.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty export statements that don't make a file a module.";
-    readonly id: "emptyExports";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "uselessExport", undefined>;
-export default _default;
-//# sourceMappingURL=emptyExports.d.ts.map

package/lib/rules/emptyExports.js

@@ -1,60 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/emptyExports.ts
-const moduleIndicatorKinds = new Set([
-	SyntaxKind.ExportAssignment,
-	SyntaxKind.ExportDeclaration,
-	SyntaxKind.ImportDeclaration,
-	SyntaxKind.ImportEqualsDeclaration
-]);
-function hasExportModifier(node) {
-	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
-}
-function hasOtherModuleIndicator(statements) {
-	return statements.some((statement) => hasExportModifier(statement) || moduleIndicatorKinds.has(statement.kind) && !isEmptyNamedExport(statement));
-}
-function isEmptyNamedExport(node) {
-	return node.kind === SyntaxKind.ExportDeclaration && !node.moduleSpecifier && node.exportClause?.kind === SyntaxKind.NamedExports && !node.exportClause.elements.length;
-}
-var emptyExports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty export statements that don't make a file a module.",
-		id: "emptyExports",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { uselessExport: {
-		primary: "Empty export does nothing and can be removed.",
-		secondary: ["An empty `export {}` statement is only useful when a file has no other imports or exports.", "When a file already has imports or exports, the empty export is redundant."],
-		suggestions: ["Remove the empty export statement."]
-	} },
-	setup(context) {
-		function checkStatements(statements, sourceFile) {
-			if (!hasOtherModuleIndicator(statements)) return;
-			for (const statement of statements) {
-				if (!isEmptyNamedExport(statement)) continue;
-				const range = getTSNodeRange(statement, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: ""
-					},
-					message: "uselessExport",
-					range
-				});
-			}
-		}
-		return { visitors: {
-			ModuleBlock: (node, { sourceFile }) => {
-				checkStatements(node.statements, sourceFile);
-			},
-			SourceFile: (node, { sourceFile }) => {
-				if (!sourceFile.fileName.endsWith(".d.ts")) checkStatements(node.statements, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyExports_default as default };
-
-//# sourceMappingURL=emptyExports.js.map

package/lib/rules/emptyFiles.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports files that contain no meaningful code.";
-    readonly id: "emptyFiles";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyFile", undefined>;
-export default _default;
-//# sourceMappingURL=emptyFiles.d.ts.map

package/lib/rules/emptyFiles.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyFiles.ts
-function isDirective(statement) {
-	return statement.kind === SyntaxKind.ExpressionStatement && statement.expression.kind === SyntaxKind.StringLiteral && /^use \w+$/.test(statement.expression.text);
-}
-function isEmptyStatement(statement) {
-	switch (statement.kind) {
-		case SyntaxKind.Block: return !statement.statements.length;
-		case SyntaxKind.EmptyStatement: return true;
-		default: return false;
-	}
-}
-function isMeaningfulStatement(statement) {
-	return !isEmptyStatement(statement) && !isDirective(statement);
-}
-var emptyFiles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports files that contain no meaningful code.",
-		id: "emptyFiles",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyFile: {
-		primary: "This file contains no meaningful code.",
-		secondary: ["Empty files clutter the codebase and often serve no purpose.", "Files containing only whitespace, comments, directives, or empty statements are considered empty."],
-		suggestions: ["Add meaningful code to the file.", "Delete the file if it's no longer needed."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile: (sourceFile) => {
-			if (!sourceFile.isDeclarationFile && !sourceFile.statements.some(isMeaningfulStatement)) context.report({
-				message: "emptyFile",
-				range: {
-					begin: 0,
-					end: 0
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { emptyFiles_default as default };
-
-//# sourceMappingURL=emptyFiles.js.map

package/lib/rules/emptyFunctions.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty functions that should contain code or a comment.";
-    readonly id: "emptyFunctions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyFunction", undefined>;
-export default _default;
-//# sourceMappingURL=emptyFunctions.d.ts.map

package/lib/rules/emptyFunctions.js

@@ -1,61 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyFunctions.ts
-function hasComments(block, sourceFile) {
-	const fullText = sourceFile.getFullText();
-	const openBrace = block.getStart(sourceFile);
-	const closeBrace = block.getEnd();
-	const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
-	return /\S+/.test(innerText.trim());
-}
-function isEmptyBlock(block, sourceFile) {
-	return !block.statements.length && !hasComments(block, sourceFile);
-}
-var emptyFunctions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty functions that should contain code or a comment.",
-		id: "emptyFunctions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyFunction: {
-		primary: "Empty functions should contain code or a comment explaining why they are empty.",
-		secondary: ["Empty functions can reduce readability because readers need to guess whether it's intentional or not.", "Adding a comment makes the intention clear."],
-		suggestions: ["Add a comment explaining why the function is intentionally empty.", "Add to the function body."]
-	} },
-	setup(context) {
-		function checkFunctionBody(node, body, sourceFile) {
-			if (body && isEmptyBlock(body, sourceFile)) context.report({
-				message: "emptyFunction",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: (node, { sourceFile }) => {
-				if (node.body.kind === SyntaxKind.Block) checkFunctionBody(node, node.body, sourceFile);
-			},
-			Constructor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			FunctionDeclaration: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			FunctionExpression: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			GetAccessor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			MethodDeclaration: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			SetAccessor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyFunctions_default as default };
-
-//# sourceMappingURL=emptyFunctions.js.map

package/lib/rules/emptyModuleAttributes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty import/export attributes that serve no purpose.";
-    readonly id: "emptyModuleAttributes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyAttributes", undefined>;
-export default _default;
-//# sourceMappingURL=emptyModuleAttributes.d.ts.map

package/lib/rules/emptyModuleAttributes.js

@@ -1,35 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyModuleAttributes.ts
-var emptyModuleAttributes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty import/export attributes that serve no purpose.",
-		id: "emptyModuleAttributes",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyAttributes: {
-		primary: "Empty import attributes serve no purpose and should be removed.",
-		secondary: ["An empty `with {}` or `assert {}` clause provides no additional information about the import.", "Remove the empty attributes clause or add the intended attributes."],
-		suggestions: ["Remove the empty attributes clause."]
-	} },
-	setup(context) {
-		function checkNode({ attributes }, { sourceFile }) {
-			if (attributes && !attributes.elements.length) context.report({
-				fix: {
-					range: getTSNodeRange(attributes, sourceFile),
-					text: ""
-				},
-				message: "emptyAttributes",
-				range: getTSNodeRange(attributes, sourceFile)
-			});
-		}
-		return { visitors: {
-			ExportDeclaration: checkNode,
-			ImportDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { emptyModuleAttributes_default as default };
-
-//# sourceMappingURL=emptyModuleAttributes.js.map

package/lib/rules/emptyObjectTypes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty object type literals and empty interfaces that are often used incorrectly.";
-    readonly id: "emptyObjectTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyInterface" | "emptyObjectType", undefined>;
-export default _default;
-//# sourceMappingURL=emptyObjectTypes.d.ts.map