@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/elseReturns.js

@@ -0,0 +1,67 @@
+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,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports empty block statements that should contain code.";
     readonly id: "emptyBlocks";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyBlock", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyBlock", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=emptyBlocks.d.ts.map

package/lib/rules/emptyBlocks.js

@@ -1,66 +1,56 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
+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([
-    ts.SyntaxKind.ArrowFunction,
-    ts.SyntaxKind.CatchClause,
-    ts.SyntaxKind.Constructor,
-    ts.SyntaxKind.FunctionDeclaration,
-    ts.SyntaxKind.FunctionExpression,
-    ts.SyntaxKind.GetAccessor,
-    ts.SyntaxKind.MethodDeclaration,
-    ts.SyntaxKind.SetAccessor,
+	SyntaxKind.ArrowFunction,
+	SyntaxKind.CatchClause,
+	SyntaxKind.Constructor,
+	SyntaxKind.FunctionDeclaration,
+	SyntaxKind.FunctionExpression,
+	SyntaxKind.GetAccessor,
+	SyntaxKind.MethodDeclaration,
+	SyntaxKind.SetAccessor
 ]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports empty block statements that should contain code.",
-        id: "emptyBlocks",
-        preset: "stylistic",
-    },
-    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) {
-            const fullText = context.sourceFile.getFullText();
-            const openBrace = block.getStart(context.sourceFile);
-            const closeBrace = block.getEnd();
-            const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
-            // Check if there are any non-whitespace characters (which would be comments)
-            // since we already know there are no statements
-            return /\S+/.test(innerText.trim());
-        }
-        function isEmptyBlock(block) {
-            return block.statements.length === 0 && !hasComments(block);
-        }
-        return {
-            visitors: {
-                Block: (node) => {
-                    if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node)) {
-                        context.report({
-                            message: "emptyBlock",
-                            range: getTSNodeRange(node, context.sourceFile),
-                        });
-                    }
-                },
-                CaseBlock: (node) => {
-                    if (node.clauses.length === 0) {
-                        context.report({
-                            message: "emptyBlock",
-                            range: getTSNodeRange(node, context.sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+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,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using empty destructuring patterns that destructure no values.";
     readonly id: "emptyDestructures";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyPattern", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyPattern", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=emptyDestructures.d.ts.map

package/lib/rules/emptyDestructures.js

@@ -1,40 +1,34 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using empty destructuring patterns that destructure no values.",
-        id: "emptyDestructures",
-        preset: "logical",
-    },
-    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) {
-            if (node.elements.length === 0) {
-                context.report({
-                    message: "emptyPattern",
-                    range: {
-                        begin: node.getStart(context.sourceFile),
-                        end: node.getEnd(),
-                    },
-                });
-            }
-        }
-        return {
-            visitors: {
-                ArrayBindingPattern: checkBindingPattern,
-                ObjectBindingPattern: checkBindingPattern,
-            },
-        };
-    },
+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

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

package/lib/rules/emptyEnums.js

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

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

package/lib/rules/emptyExports.js

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

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

package/lib/rules/emptyFiles.js

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

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

package/lib/rules/emptyFunctions.js

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

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

package/lib/rules/emptyModuleAttributes.js

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

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

package/lib/rules/emptyObjectTypes.js

@@ -0,0 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/emptyObjectTypes.ts
+var emptyObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty object type literals and empty interfaces that are often used incorrectly.",
+		id: "emptyObjectTypes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		emptyInterface: {
+			primary: "Empty interfaces are often used incorrectly and should be avoided.",
+			secondary: ["An empty interface `interface Foo {}` is equivalent to the `{}` type, which matches any non-nullish value.", "Consider using `object` for any object, `unknown` for any value, or adding members to the interface."],
+			suggestions: ["Add members to the interface, or use `object` or `unknown` instead."]
+		},
+		emptyObjectType: {
+			primary: "The `{}` type means 'any non-nullish value' and is often used incorrectly.",
+			secondary: ["The `{}` type allows any value except `null` and `undefined`, including primitives like strings and numbers.", "If you want to represent any object, use `object`. If you want any value, use `unknown`."],
+			suggestions: ["Use `object` for any object value, or `unknown` for any value including `null` and `undefined`."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			InterfaceDeclaration: (node, { sourceFile }) => {
+				if (node.members.length) return false;
+				const extendsClause = node.heritageClauses?.find((clause) => clause.token === SyntaxKind.ExtendsKeyword);
+				if (extendsClause && extendsClause.types.length > 1) return;
+				context.report({
+					message: "emptyInterface",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			TypeLiteral: (node, { sourceFile }) => {
+				if (node.members.length || node.parent.kind === SyntaxKind.IntersectionType || node.parent.kind === SyntaxKind.MappedType) return;
+				context.report({
+					message: "emptyObjectType",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { emptyObjectTypes_default as default };
+
+//# sourceMappingURL=emptyObjectTypes.js.map