@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/deprecated.js

@@ -1,241 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/deprecated.ts
-var deprecated_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow using code marked as @deprecated.",
-		id: "deprecated",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { deprecated: {
-		primary: "This is deprecated.",
-		secondary: ["The @deprecated JSDoc tag indicates this code should no longer be used.", "Deprecated code may be removed in future versions."],
-		suggestions: ["Find a non-deprecated alternative."]
-	} },
-	setup(context) {
-		function getJsDocDeprecation(symbol, typeChecker) {
-			if (!symbol) return false;
-			let jsDocTags;
-			try {
-				jsDocTags = symbol.getJsDocTags(typeChecker);
-			} catch {
-				return false;
-			}
-			return jsDocTags.some((tag) => tag.name === "deprecated");
-		}
-		function isDeprecatedFromDeclarations(symbol) {
-			return symbol?.getDeclarations()?.some((declaration) => {
-				return ts$1.getJSDocTags(declaration).some((tag) => tag.tagName.text === "deprecated" || tag.tagName.text === "Deprecated");
-			});
-		}
-		function searchForDeprecationInAliasesChain(symbol, typeChecker, checkAliasedSymbol) {
-			if (!symbol) return false;
-			if (!(symbol.flags & ts$1.SymbolFlags.Alias)) return !!(checkAliasedSymbol && (getJsDocDeprecation(symbol, typeChecker) || isDeprecatedFromDeclarations(symbol)));
-			const targetSymbol = typeChecker.getAliasedSymbol(symbol);
-			let current = symbol;
-			while (current.flags & ts$1.SymbolFlags.Alias) {
-				if (getJsDocDeprecation(current, typeChecker) || isDeprecatedFromDeclarations(current)) return true;
-				if (!current.getDeclarations()) break;
-				const immediateAliased = typeChecker.getImmediateAliasedSymbol(current);
-				if (!immediateAliased) break;
-				current = immediateAliased;
-				if (checkAliasedSymbol && current === targetSymbol) return !!(getJsDocDeprecation(current, typeChecker) || isDeprecatedFromDeclarations(current));
-			}
-			return false;
-		}
-		function isDeprecated(symbol, typeChecker) {
-			return searchForDeprecationInAliasesChain(symbol, typeChecker, true);
-		}
-		function isDeclarationSite(node) {
-			switch (node.parent.kind) {
-				case ts$1.SyntaxKind.ArrowFunction:
-				case ts$1.SyntaxKind.ClassDeclaration:
-				case ts$1.SyntaxKind.Constructor:
-				case ts$1.SyntaxKind.EnumDeclaration:
-				case ts$1.SyntaxKind.EnumMember:
-				case ts$1.SyntaxKind.FunctionDeclaration:
-				case ts$1.SyntaxKind.FunctionExpression:
-				case ts$1.SyntaxKind.GetAccessor:
-				case ts$1.SyntaxKind.InterfaceDeclaration:
-				case ts$1.SyntaxKind.MethodDeclaration:
-				case ts$1.SyntaxKind.MethodSignature:
-				case ts$1.SyntaxKind.ModuleDeclaration:
-				case ts$1.SyntaxKind.Parameter:
-				case ts$1.SyntaxKind.PropertyDeclaration:
-				case ts$1.SyntaxKind.PropertySignature:
-				case ts$1.SyntaxKind.SetAccessor:
-				case ts$1.SyntaxKind.TypeAliasDeclaration:
-				case ts$1.SyntaxKind.TypeParameter:
-				case ts$1.SyntaxKind.VariableDeclaration: return node.parent.name === node;
-				case ts$1.SyntaxKind.ExportSpecifier: return node.parent.propertyName === node;
-				case ts$1.SyntaxKind.ImportClause:
-				case ts$1.SyntaxKind.ImportSpecifier:
-				case ts$1.SyntaxKind.NamespaceImport: return true;
-				case ts$1.SyntaxKind.PropertyAssignment: return node.parent.name === node && !ts$1.isComputedPropertyName(node.parent.name) && ts$1.isObjectLiteralExpression(node.parent.parent);
-			}
-		}
-		function getCallLikeExpression(node) {
-			let current = node;
-			while (ts$1.isPropertyAccessExpression(current.parent) && current.parent.name === current) current = current.parent;
-			while (ts$1.isElementAccessExpression(current.parent) && current.parent.argumentExpression === current) current = current.parent;
-			switch (current.parent.kind) {
-				case ts$1.SyntaxKind.CallExpression:
-				case ts$1.SyntaxKind.Decorator:
-				case ts$1.SyntaxKind.NewExpression: return current.parent.expression === current && current.parent;
-				case ts$1.SyntaxKind.TaggedTemplateExpression: return current.parent.tag === current && current.parent;
-			}
-		}
-		function getCallLikeDeprecation(node, callLike, typeChecker) {
-			const signature = typeChecker.getResolvedSignature(callLike);
-			const symbol = typeChecker.getSymbolAtLocation(node);
-			const aliasedSymbol = symbol && symbol.flags & ts$1.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol) : symbol;
-			const symbolDeclarationKind = aliasedSymbol?.declarations?.[0]?.kind;
-			if (symbolDeclarationKind !== ts$1.SyntaxKind.MethodDeclaration && symbolDeclarationKind !== ts$1.SyntaxKind.FunctionDeclaration && symbolDeclarationKind !== ts$1.SyntaxKind.MethodSignature) return searchForDeprecationInAliasesChain(symbol, typeChecker, true) || getJsDocDeprecation(signature, typeChecker) || isDeprecatedFromDeclarations(aliasedSymbol);
-			return searchForDeprecationInAliasesChain(symbol, typeChecker, false) || getJsDocDeprecation(signature, typeChecker);
-		}
-		function checkNode(node, sourceFile, typeChecker) {
-			if (isDeclarationSite(node) || isInsideImport(node)) return;
-			const callLike = getCallLikeExpression(node);
-			if (callLike) {
-				if (getCallLikeDeprecation(node, callLike, typeChecker)) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (ts$1.isShorthandPropertyAssignment(node.parent) && node.parent.name === node) {
-				const symbol = typeChecker.getSymbolAtLocation(node);
-				const valueSymbol = symbol && typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
-				if (valueSymbol && (getJsDocDeprecation(valueSymbol, typeChecker) || isDeprecatedFromDeclarations(valueSymbol))) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (isDeprecated(typeChecker.getSymbolAtLocation(node), typeChecker)) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		function checkComputedPropertyAccess(node, sourceFile, typeChecker) {
-			const argumentExpression = node.argumentExpression;
-			const argumentType = typeChecker.getTypeAtLocation(argumentExpression);
-			if (!argumentType.isLiteral()) return;
-			const objectType = typeChecker.getTypeAtLocation(node.expression);
-			let propertyName;
-			if (argumentType.isStringLiteral()) propertyName = argumentType.value;
-			else if (argumentType.isNumberLiteral()) propertyName = String(argumentType.value);
-			else return;
-			const property = objectType.getProperty(propertyName);
-			if (property && (getJsDocDeprecation(property, typeChecker) || isDeprecatedFromDeclarations(property))) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(argumentExpression, sourceFile)
-			});
-		}
-		function checkBindingElement(node, sourceFile, typeChecker) {
-			const bindingPattern = node.parent;
-			if (!ts$1.isObjectBindingPattern(bindingPattern)) return;
-			const propertyName = node.propertyName ?? node.name;
-			if (!ts$1.isIdentifier(propertyName)) return;
-			const declarationOrPattern = bindingPattern.parent;
-			let objectType;
-			if (ts$1.isVariableDeclaration(declarationOrPattern)) {
-				const initializer = declarationOrPattern.initializer;
-				if (initializer) objectType = typeChecker.getTypeAtLocation(initializer);
-			} else if (ts$1.isBindingElement(declarationOrPattern)) {
-				const parentInitializer = declarationOrPattern.parent.parent;
-				if (ts$1.isVariableDeclaration(parentInitializer)) {
-					const init = parentInitializer.initializer;
-					if (init) {
-						const parentType = typeChecker.getTypeAtLocation(init);
-						const parentPropertyName = declarationOrPattern.propertyName ?? declarationOrPattern.name;
-						if (ts$1.isIdentifier(parentPropertyName)) {
-							const prop = parentType.getProperty(parentPropertyName.text);
-							if (prop) objectType = typeChecker.getTypeOfSymbolAtLocation(prop, parentInitializer);
-						}
-					}
-				}
-			}
-			if (objectType) {
-				const property = objectType.getProperty(propertyName.text);
-				if (property && (getJsDocDeprecation(property, typeChecker) || isDeprecatedFromDeclarations(property))) {
-					const reportNode = node.propertyName ?? node.name;
-					if (ts$1.isIdentifier(reportNode)) context.report({
-						message: "deprecated",
-						range: getTSNodeRange(reportNode, sourceFile)
-					});
-				}
-			}
-		}
-		function checkHeritageClause(node, sourceFile, typeChecker) {
-			for (const type of node.types) if (ts$1.isIdentifier(type.expression)) {
-				if (isDeprecated(typeChecker.getSymbolAtLocation(type.expression), typeChecker)) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(type.expression, sourceFile)
-				});
-			}
-		}
-		function checkSuperCall(node, sourceFile, typeChecker) {
-			const callExpr = node.parent;
-			if (!ts$1.isCallExpression(callExpr) || callExpr.expression !== node) return;
-			const signature = typeChecker.getResolvedSignature(callExpr);
-			if (signature && getJsDocDeprecation(signature, typeChecker)) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			BindingElement: (node, { sourceFile, typeChecker }) => {
-				checkBindingElement(node, sourceFile, typeChecker);
-			},
-			ElementAccessExpression: (node, { sourceFile, typeChecker }) => {
-				checkComputedPropertyAccess(node, sourceFile, typeChecker);
-			},
-			HeritageClause: (node, { sourceFile, typeChecker }) => {
-				checkHeritageClause(node, sourceFile, typeChecker);
-			},
-			Identifier: (node, { sourceFile, typeChecker }) => {
-				if (isInsideHeritageClause(node)) return;
-				if (ts$1.isPropertyAccessExpression(node.parent) && node === node.parent.name) {
-					checkNode(node, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isQualifiedName(node.parent) && node === node.parent.right) {
-					checkNode(node, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isElementAccessExpression(node.parent) && node === node.parent.argumentExpression) return;
-				checkNode(node, sourceFile, typeChecker);
-			},
-			PrivateIdentifier: (node, { sourceFile, typeChecker }) => {
-				if (ts$1.isPropertyAccessExpression(node.parent) && node === node.parent.name) checkNode(node, sourceFile, typeChecker);
-			},
-			SuperKeyword: (node, { sourceFile, typeChecker }) => {
-				checkSuperCall(node, sourceFile, typeChecker);
-			}
-		} };
-	}
-});
-function isInsideHeritageClause(node) {
-	if (ts$1.isHeritageClause(node)) return true;
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isHeritageClause(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isClassDeclaration(current)) break;
-		current = current.parent;
-	}
-	return false;
-}
-function isInsideImport(node) {
-	if (ts$1.isImportDeclaration(node)) return true;
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isImportDeclaration(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isClassDeclaration(current) || ts$1.isClassExpression(current) || ts$1.isBlock(current)) return false;
-		current = current.parent;
-	}
-	return false;
-}
-//#endregion
-export { deprecated_default as default };

package/lib/rules/destructuringConsistency.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Use destructured variables over properties for consistency.";
-    readonly id: "destructuringConsistency";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useDestructured", undefined>;
-export default _default;

package/lib/rules/destructuringConsistency.js

@@ -1,104 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/destructuringConsistency.ts
-function isInScope(accessScope, declarationScope) {
-	let current = accessScope;
-	while (current) {
-		if (current === declarationScope) return true;
-		current = current.upper;
-	}
-	return false;
-}
-function getInitializerKey(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.Identifier: return node.text;
-		case ts$1.SyntaxKind.PropertyAccessExpression: {
-			if (node.questionDotToken) return;
-			const objectKey = getInitializerKey(node.expression);
-			if (!objectKey) return;
-			return `${objectKey}.${node.name.text}`;
-		}
-		case ts$1.SyntaxKind.ThisKeyword: return "this";
-	}
-}
-function isLeftHandSide(node) {
-	switch (node.parent.kind) {
-		case ts$1.SyntaxKind.BinaryExpression: return node.parent.left === node && node.parent.operatorToken.kind >= ts$1.SyntaxKind.FirstAssignment && node.parent.operatorToken.kind <= ts$1.SyntaxKind.LastAssignment;
-		case ts$1.SyntaxKind.DeleteExpression: return true;
-		case ts$1.SyntaxKind.PostfixUnaryExpression:
-		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts$1.SyntaxKind.PlusPlusToken || node.parent.operator === ts$1.SyntaxKind.MinusMinusToken;
-		default: return false;
-	}
-}
-var destructuringConsistency_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Use destructured variables over properties for consistency.",
-		id: "destructuringConsistency",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { useDestructured: {
-		primary: "Use the destructured variable instead of accessing the property again.",
-		secondary: ["After destructuring an object, access properties through the destructured variables.", "Mixing destructured variables with property access on the same object is inconsistent."],
-		suggestions: ["Replace `{{ expression }}` with `{{ variable }}`."]
-	} },
-	setup(context) {
-		const destructuredObjects = [];
-		return { visitors: {
-			PropertyAccessExpression: (node, { sourceFile }) => {
-				if (node.questionDotToken) return;
-				const accessKey = getInitializerKey(node.expression);
-				if (!accessKey) return;
-				const accessScope = getScopeManager(sourceFile).getScope(node);
-				const destructured = destructuredObjects.find((object) => object.initKey === accessKey && node.getStart(sourceFile) >= object.declarationEnd && isInScope(accessScope, object.scope));
-				if (!destructured) return;
-				const propertyName = node.name.text;
-				if (!destructured.destructuredProperties.has(propertyName)) return;
-				const variableName = destructured.destructuredProperties.get(propertyName);
-				if (ts$1.isCallExpression(node.parent) && node.parent.expression === node || isLeftHandSide(node)) return;
-				const range = getTSNodeRange(node, sourceFile);
-				const expression = node.getText(sourceFile);
-				const [variable, suggestions] = variableName ? [variableName, [{
-					id: "useDestructuredVariable",
-					range,
-					text: variableName
-				}]] : [propertyName];
-				context.report({
-					data: {
-						expression,
-						variable
-					},
-					message: "useDestructured",
-					range,
-					suggestions
-				});
-			},
-			"SourceFile:exit"() {
-				destructuredObjects.length = 0;
-			},
-			VariableDeclaration: (node, { sourceFile }) => {
-				if (!node.initializer || !ts$1.isObjectBindingPattern(node.name)) return;
-				const initKey = getInitializerKey(node.initializer);
-				if (!initKey) return;
-				const properties = /* @__PURE__ */ new Map();
-				for (const element of node.name.elements) {
-					if (!ts$1.isBindingElement(element)) continue;
-					if (element.propertyName) {
-						if (ts$1.isIdentifier(element.propertyName)) {
-							if (ts$1.isObjectBindingPattern(element.name) || ts$1.isArrayBindingPattern(element.name)) properties.set(element.propertyName.text, null);
-							else if (ts$1.isIdentifier(element.name)) properties.set(element.propertyName.text, element.name.text);
-						}
-					} else if (ts$1.isIdentifier(element.name)) properties.set(element.name.text, element.name.text);
-				}
-				if (properties.size) destructuredObjects.push({
-					declarationEnd: node.getEnd(),
-					destructuredProperties: properties,
-					initKey,
-					scope: getScopeManager(sourceFile).getScope(node)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { destructuringConsistency_default as default };

package/lib/rules/duplicateArguments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports functions with duplicate parameter names in their signatures.";
-    readonly id: "duplicateArguments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateParam", undefined>;
-export default _default;

package/lib/rules/duplicateArguments.js

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

package/lib/rules/dynamicDeletes.d.ts

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

package/lib/rules/dynamicDeletes.js

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

package/lib/rules/elseIfDuplicates.d.ts

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

package/lib/rules/elseIfDuplicates.js

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

package/lib/rules/elseReturns.d.ts

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

package/lib/rules/elseReturns.js

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

package/lib/rules/emptyBlocks.d.ts

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

package/lib/rules/emptyBlocks.js

@@ -1,54 +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 = /* @__PURE__ */ 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 };

package/lib/rules/emptyDestructures.d.ts

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