@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/asyncPromiseExecutors.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/asyncPromiseExecutors.ts
-var asyncPromiseExecutors_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using async functions as Promise executor functions.",
-		id: "asyncPromiseExecutors",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { asyncPromiseExecutor: {
-		primary: "Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
-		secondary: [
-			"The Promise executor function is called synchronously by the Promise constructor.",
-			"If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
-			"Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor."
-		],
-		suggestions: ["Remove the `async` keyword from the executor function.", "If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor."]
-	} },
-	setup(context) {
-		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!isGlobalDeclaration(node.expression, typeChecker, program) || !node.arguments?.length) return;
-			const executor = nullThrows(node.arguments[0], "Expected there to be a promise executor!");
-			if (executor.kind !== SyntaxKind.FunctionExpression && executor.kind !== SyntaxKind.ArrowFunction) return;
-			const asyncModifier = executor.modifiers?.find((mod) => mod.kind === SyntaxKind.AsyncKeyword);
-			if (!asyncModifier) return;
-			context.report({
-				message: "asyncPromiseExecutor",
-				range: {
-					begin: asyncModifier.getStart(sourceFile),
-					end: asyncModifier.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { asyncPromiseExecutors_default as default };

package/lib/rules/asyncUnnecessaryPromiseWrappers.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.";
-    readonly id: "asyncUnnecessaryPromiseWrappers";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryReject" | "unnecessaryResolve", undefined>;
-export default _default;

package/lib/rules/asyncUnnecessaryPromiseWrappers.js

@@ -1,50 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/asyncUnnecessaryPromiseWrappers.ts
-var asyncUnnecessaryPromiseWrappers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.",
-		id: "asyncUnnecessaryPromiseWrappers",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		unnecessaryReject: {
-			primary: "Errors can be thrown directly instead of wrapping in `Promise.reject()`.",
-			secondary: ["In async functions, thrown errors are automatically converted to rejected promises.", "Using `Promise.reject()` is unnecessary and less idiomatic."],
-			suggestions: ["Throw the error directly instead of using `Promise.reject()`."]
-		},
-		unnecessaryResolve: {
-			primary: "Return values in async functions are already wrapped in a `Promise`.",
-			secondary: ["Wrapping a value in `Promise.resolve()` is unnecessary in async functions.", "This adds extra code without changing the behavior."],
-			suggestions: ["Return the value directly instead of wrapping it."]
-		}
-	},
-	setup(context) {
-		return { visitors: { ArrowFunction: (node, { sourceFile }) => {
-			if (!isAsyncFunction(node) || !ts$1.isCallExpression(node.body)) return;
-			const message = getMessageForBody(node.body);
-			if (!message) return;
-			context.report({
-				message,
-				range: {
-					begin: node.body.getStart(sourceFile),
-					end: node.body.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function getMessageForBody(node) {
-	if (!ts$1.isPropertyAccessExpression(node.expression) || !ts$1.isIdentifier(node.expression.expression) || node.expression.expression.text !== "Promise") return;
-	switch (node.expression.name.text) {
-		case "reject": return "unnecessaryReject";
-		case "resolve": return "unnecessaryResolve";
-		default: return;
-	}
-}
-function isAsyncFunction(node) {
-	return node.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
-}
-//#endregion
-export { asyncUnnecessaryPromiseWrappers_default as default };

package/lib/rules/atAccesses.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer using .at() for accessing elements at negative indices.";
-    readonly id: "atAccesses";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferAt", undefined>;
-export default _default;

package/lib/rules/atAccesses.js

@@ -1,50 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/atAccesses.ts
-var atAccesses_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer using .at() for accessing elements at negative indices.",
-		id: "atAccesses",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferAt: {
-		primary: "Prefer using .at() with a negative index instead of calculating length minus an offset.",
-		secondary: ["The .at() method provides a cleaner way to access elements from the end of an array or string.", "Using .at(-1) is more readable than array[array.length - 1]."],
-		suggestions: ["Use .at() with a negative index to access elements from the end."]
-	} },
-	setup(context) {
-		return { visitors: { ElementAccessExpression: (node, { sourceFile }) => {
-			if (!isLeftHandSide(node) && isLengthMinusAccess(node, sourceFile)) context.report({
-				message: "preferAt",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-function isLeftHandSide(node) {
-	switch (node.parent.kind) {
-		case ts$1.SyntaxKind.ArrayLiteralExpression: return ts$1.isBinaryExpression(node.parent.parent) && tsutils.isAssignmentKind(node.parent.parent.operatorToken.kind) && node.parent.parent.left === node.parent;
-		case ts$1.SyntaxKind.BinaryExpression: return tsutils.isAssignmentKind(node.parent.operatorToken.kind) && node.parent.left === node;
-		case ts$1.SyntaxKind.DeleteExpression: return true;
-		case ts$1.SyntaxKind.PostfixUnaryExpression:
-		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operand === node;
-		case ts$1.SyntaxKind.PropertyAssignment:
-		case ts$1.SyntaxKind.ShorthandPropertyAssignment: return node.parent.parent.parent.kind === ts$1.SyntaxKind.BinaryExpression && tsutils.isAssignmentKind(node.parent.parent.parent.operatorToken.kind) && node.parent.parent.parent.left === node.parent.parent;
-	}
-	return false;
-}
-function isLengthMinusAccess(node, sourceFile) {
-	const argument = unwrapParenthesizedNode(node.argumentExpression);
-	if (!ts$1.isBinaryExpression(argument) || argument.operatorToken.kind !== ts$1.SyntaxKind.MinusToken) return false;
-	const left = unwrapParenthesizedNode(argument.left);
-	if (!ts$1.isPropertyAccessExpression(left) || left.name.text !== "length" || !hasSameTokens(left.expression, node.expression, sourceFile)) return false;
-	const right = unwrapParenthesizedNode(argument.right);
-	if (!ts$1.isNumericLiteral(right)) return false;
-	const offset = Number(right.text);
-	if (!Number.isInteger(offset) || offset <= 0) return false;
-	return true;
-}
-//#endregion
-export { atAccesses_default as default };

package/lib/rules/builtinCoercions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.";
-    readonly id: "builtinCoercions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useBuiltin", undefined>;
-export default _default;

package/lib/rules/builtinCoercions.js

@@ -1,115 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/builtinCoercions.ts
-const nativeCoercionFunctions = /* @__PURE__ */ new Set([
-	"BigInt",
-	"Boolean",
-	"Number",
-	"String",
-	"Symbol"
-]);
-const arrayMethodsWithBooleanCallback = /* @__PURE__ */ new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"some"
-]);
-var builtinCoercions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.",
-		id: "builtinCoercions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { useBuiltin: {
-		primary: "Prefer using `{{ coercionFunction }}` directly instead of wrapping it in a function.",
-		secondary: ["Wrapping a native coercion function in another function adds unnecessary indirection.", "Using the built-in function directly is more concise and expresses intent more clearly."],
-		suggestions: ["Replace this function with `{{ coercionFunction }}`."]
-	} },
-	setup(context) {
-		function checkFunction(node, { sourceFile }) {
-			const problem = getFunctionProblem(node, sourceFile);
-			if (problem) context.report(problem);
-		}
-		return { visitors: {
-			ArrowFunction: checkFunction,
-			FunctionExpression: checkFunction
-		} };
-	}
-});
-function blockReturnsIdentifier(block, parameterName) {
-	if (block.statements.length !== 1) return false;
-	const statement = block.statements[0];
-	if (!statement || !ts$1.isReturnStatement(statement) || !statement.expression) return false;
-	return expressionMatchesName(statement.expression, parameterName);
-}
-function expressionMatchesName(expression, name) {
-	const unwrapped = ts$1.isParenthesizedExpression(expression) ? expression.expression : expression;
-	return ts$1.isIdentifier(unwrapped) && unwrapped.text === name;
-}
-function getCoercionCallName(expression, parameterName) {
-	if (!ts$1.isCallExpression(expression) || !ts$1.isIdentifier(expression.expression)) return;
-	const calleeName = expression.expression.text;
-	if (!nativeCoercionFunctions.has(calleeName) || expression.arguments.length !== 1) return;
-	const argument = expression.arguments[0];
-	if (!argument || !ts$1.isIdentifier(argument) || argument.text !== parameterName) return;
-	return calleeName;
-}
-function getCoercionWrapperProblem(node, parameterName, sourceFile) {
-	if (node.parameters.length !== 1) return;
-	const coercionFunction = getWrappedCoercionFunction(node, parameterName);
-	if (!coercionFunction) return;
-	const range = getTSNodeRange(node, sourceFile);
-	return {
-		data: { coercionFunction },
-		fix: {
-			range,
-			text: coercionFunction
-		},
-		message: "useBuiltin",
-		range
-	};
-}
-function getFunctionProblem(node, sourceFile) {
-	const soleParameterText = getSoleParameterText(node);
-	if (!soleParameterText) return;
-	return getIdentityCallbackProblem(node, soleParameterText, sourceFile) ?? getCoercionWrapperProblem(node, soleParameterText, sourceFile);
-}
-function getIdentityCallbackProblem(node, soleParameterText, sourceFile) {
-	if (!isIdentityFunction(node, soleParameterText) || !isArrayMethodCallback(node)) return;
-	const range = getTSNodeRange(node, sourceFile);
-	return {
-		data: { coercionFunction: "Boolean" },
-		fix: {
-			range,
-			text: "Boolean"
-		},
-		message: "useBuiltin",
-		range
-	};
-}
-function getSoleParameterText(node) {
-	if (node.parameters.length !== 1) return;
-	const parameter = node.parameters[0];
-	if (!parameter || !ts$1.isIdentifier(parameter.name)) return;
-	return parameter.name.text;
-}
-function getWrappedCoercionFunction(node, parameterName) {
-	if (node.kind === ts$1.SyntaxKind.ArrowFunction && !ts$1.isBlock(node.body)) return getCoercionCallName(node.body, parameterName);
-	if (!ts$1.isBlock(node.body) || node.body.statements.length !== 1) return;
-	const statement = node.body.statements[0];
-	if (!statement || !ts$1.isReturnStatement(statement) || !statement.expression) return;
-	return getCoercionCallName(statement.expression, parameterName);
-}
-function isArrayMethodCallback(node) {
-	return ts$1.isCallExpression(node.parent) && node.parent.arguments[0] === node && ts$1.isPropertyAccessExpression(node.parent.expression) && arrayMethodsWithBooleanCallback.has(node.parent.expression.name.text);
-}
-function isIdentityFunction(node, soleParameterText) {
-	if (node.kind === ts$1.SyntaxKind.ArrowFunction && !ts$1.isBlock(node.body)) return expressionMatchesName(node.body, soleParameterText);
-	return ts$1.isBlock(node.body) && blockReturnsIdentifier(node.body, soleParameterText);
-}
-//#endregion
-export { builtinCoercions_default as default };

package/lib/rules/builtinConstructorNews.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces using new for constructors that require it, and disallows new for primitive coercion functions.";
-    readonly id: "builtinConstructorNews";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "disallowedNew" | "missingNew", undefined>;
-export default _default;

package/lib/rules/builtinConstructorNews.js

@@ -1,87 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/builtinConstructorNews.ts
-const requiresNew = /* @__PURE__ */ new Set([
-	"Array",
-	"ArrayBuffer",
-	"BigInt64Array",
-	"BigUint64Array",
-	"DataView",
-	"Date",
-	"Error",
-	"FinalizationRegistry",
-	"Float16Array",
-	"Float32Array",
-	"Float64Array",
-	"Function",
-	"Int8Array",
-	"Int16Array",
-	"Int32Array",
-	"Map",
-	"Object",
-	"Promise",
-	"Proxy",
-	"RegExp",
-	"Set",
-	"SharedArrayBuffer",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Uint16Array",
-	"Uint32Array",
-	"WeakMap",
-	"WeakRef",
-	"WeakSet"
-]);
-const disallowsNew = /* @__PURE__ */ new Set([
-	"BigInt",
-	"Boolean",
-	"Number",
-	"String",
-	"Symbol"
-]);
-var builtinConstructorNews_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces using new for constructors that require it, and disallows new for primitive coercion functions.",
-		id: "builtinConstructorNews",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		disallowedNew: {
-			primary: "Use {{ name }}() without new to coerce values to primitives.",
-			secondary: ["Using `new` with `{{ name }}` creates an object wrapper around the primitive value.", "Object wrappers can cause unexpected behavior in comparisons and type checks."],
-			suggestions: ["Remove `new` to use {{ name }} as a coercion function."]
-		},
-		missingNew: {
-			primary: "Use new {{ name }}() to create instances.",
-			secondary: ["Built-in constructors like `{{ name }}` should be called with `new` for consistency.", "While some constructors work without `new`, using `new` makes the intent clearer."],
-			suggestions: ["Add `new` before {{ name }}()."]
-		}
-	},
-	setup(context) {
-		function checkNode(node, namesToReport, message, { program, sourceFile, typeChecker }) {
-			if (!ts$1.isIdentifier(node.expression)) return;
-			const name = node.expression.text;
-			if (!namesToReport.has(name)) return;
-			if (!isGlobalDeclarationOfName(node.expression, name, typeChecker, program)) return;
-			context.report({
-				data: { name },
-				message,
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.expression.getEnd()
-				}
-			});
-		}
-		return { visitors: {
-			CallExpression: (node, services) => {
-				checkNode(node, requiresNew, "missingNew", services);
-			},
-			NewExpression: (node, services) => {
-				checkNode(node, disallowsNew, "disallowedNew", services);
-			}
-		} };
-	}
-});
-//#endregion
-export { builtinConstructorNews_default as default };

package/lib/rules/caseDeclarations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
-    readonly id: "caseDeclarations";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedLexicalDeclaration", undefined>;
-export default _default;

package/lib/rules/caseDeclarations.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/caseDeclarations.ts
-var caseDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports lexical declarations in case clauses without wrapping them in blocks.",
-		id: "caseDeclarations",
-		presets: ["javascript"]
-	},
-	messages: { unexpectedLexicalDeclaration: {
-		primary: "Variables declared in case clauses without braces leak into the surrounding scope.",
-		secondary: ["Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.", "This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope."],
-		suggestions: ["Wrap the case clause contents in curly braces {} to create a block scope."]
-	} },
-	setup(context) {
-		function getLexicalDeclaration(statements, sourceFile) {
-			for (const statement of statements) {
-				if (statement.kind === SyntaxKind.VariableStatement && tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) return statement.declarationList.getChildAt(0, sourceFile);
-				if (statement.kind === SyntaxKind.ClassDeclaration || statement.kind === SyntaxKind.FunctionDeclaration) return statement.getChildAt(0, sourceFile);
-			}
-		}
-		function checkClause(node, { sourceFile }) {
-			const declarationNode = getLexicalDeclaration(node.statements, sourceFile);
-			if (declarationNode) context.report({
-				message: "unexpectedLexicalDeclaration",
-				range: getTSNodeRange(declarationNode, sourceFile)
-			});
-		}
-		return { visitors: {
-			CaseClause: checkClause,
-			DefaultClause: checkClause
-		} };
-	}
-});
-//#endregion
-export { caseDeclarations_default as default };

package/lib/rules/caseDuplicates.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports switch statements with duplicate case clause test expressions.";
-    readonly id: "caseDuplicates";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateCase", undefined>;
-export default _default;

package/lib/rules/caseDuplicates.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/caseDuplicates.ts
-var caseDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports switch statements with duplicate case clause test expressions.",
-		id: "caseDuplicates",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { duplicateCase: {
-		primary: "This case duplicates a previous case, so it will never be reached.",
-		secondary: ["Having duplicate case clauses in a switch statement is a logic error.", "The second case clause will never be reached because the first matching case will always execute first."],
-		suggestions: ["Remove the duplicate case clause or modify its test expression to be unique."]
-	} },
-	setup(context) {
-		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
-			const seenCases = [];
-			for (const clause of node.caseBlock.clauses) {
-				if (clause.kind !== SyntaxKind.CaseClause) continue;
-				if (seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, sourceFile))) context.report({
-					message: "duplicateCase",
-					range: {
-						begin: clause.getStart(sourceFile),
-						end: clause.expression.getEnd()
-					}
-				});
-				else seenCases.push(clause.expression);
-			}
-		} } };
-	}
-});
-//#endregion
-export { caseDuplicates_default as default };

package/lib/rules/caseFallthroughs.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports switch case clauses that fall through unexpectedly.";
-    readonly id: "caseFallthroughs";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedFallthrough", undefined>;
-export default _default;

package/lib/rules/caseFallthroughs.js

@@ -1,74 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/caseFallthroughs.ts
-const fallthroughCommentPattern = /falls?\s*through/i;
-function endsWithTerminatingStatement(statements) {
-	return !!statements.length && isTerminatingStatement(statements.at(-1));
-}
-function hasFallthroughComment(clause, nextClause, sourceFile) {
-	const sourceText = sourceFile.getFullText();
-	const commentRanges = ts$1.getLeadingCommentRanges(sourceText, nextClause.getFullStart());
-	if (commentRanges) for (const range of commentRanges) {
-		const comment = sourceText.slice(range.pos, range.end);
-		if (fallthroughCommentPattern.test(comment)) return true;
-	}
-	const trailingRanges = ts$1.getTrailingCommentRanges(sourceText, clause.getEnd());
-	if (trailingRanges) for (const range of trailingRanges) {
-		const comment = sourceText.slice(range.pos, range.end);
-		if (fallthroughCommentPattern.test(comment)) return true;
-	}
-	return false;
-}
-function isTerminatingStatement(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.Block: return endsWithTerminatingStatement(node.statements);
-		case ts$1.SyntaxKind.BreakStatement:
-		case ts$1.SyntaxKind.ContinueStatement:
-		case ts$1.SyntaxKind.ReturnStatement:
-		case ts$1.SyntaxKind.ThrowStatement: return true;
-		case ts$1.SyntaxKind.IfStatement: return !!node.elseStatement && isTerminatingStatement(node.thenStatement) && isTerminatingStatement(node.elseStatement);
-		case ts$1.SyntaxKind.SwitchStatement: return node.caseBlock.clauses.some(ts$1.isDefaultClause) && node.caseBlock.clauses.every((clause) => !clause.statements.length || endsWithTerminatingStatement(clause.statements));
-		case ts$1.SyntaxKind.TryStatement:
-			if (node.finallyBlock) return endsWithTerminatingStatement(node.finallyBlock.statements);
-			if (!node.catchClause) return endsWithTerminatingStatement(node.tryBlock.statements);
-			return endsWithTerminatingStatement(node.tryBlock.statements) && endsWithTerminatingStatement(node.catchClause.block.statements);
-		default: return false;
-	}
-}
-var caseFallthroughs_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports switch case clauses that fall through unexpectedly.",
-		id: "caseFallthroughs",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unexpectedFallthrough: {
-		primary: "This case falls through to the next case without a break, return, or throw statement.",
-		secondary: ["Fallthrough in switch statements is often unintentional and can lead to bugs.", "If fallthrough is intentional, add a comment containing 'falls through' to indicate this."],
-		suggestions: [
-			"Add a `break` statement at the end of this case.",
-			"Add a `return` or `throw` statement if appropriate.",
-			"If fallthrough is intentional, add a `// falls through` comment."
-		]
-	} },
-	setup(context) {
-		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
-			for (let i = 0; i < node.caseBlock.clauses.length - 1; i++) {
-				const clause = node.caseBlock.clauses[i];
-				if (!clause) continue;
-				const nextClause = node.caseBlock.clauses[i + 1];
-				if (!clause.statements.length || endsWithTerminatingStatement(clause.statements) || hasFallthroughComment(clause, nextClause, sourceFile)) continue;
-				const caseKeyword = ts$1.isCaseClause(clause) ? "case" : "default";
-				context.report({
-					message: "unexpectedFallthrough",
-					range: {
-						begin: clause.getStart(sourceFile),
-						end: clause.getStart(sourceFile) + caseKeyword.length
-					}
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { caseFallthroughs_default as default };

package/lib/rules/catchCallbackTypes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `Promise` catch callback parameters that are not typed as unknown.";
-    readonly id: "catchCallbackTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferUnknown", undefined>;
-export default _default;

package/lib/rules/catchCallbackTypes.js

@@ -1,65 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { declarationIncludesGlobal, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { TypeFlags, isFunctionLike, isInterfaceDeclaration, isPropertyAccessExpression } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/catchCallbackTypes.ts
-var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `Promise` catch callback parameters that are not typed as unknown.",
-		id: "catchCallbackTypes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferUnknown: {
-		primary: "The catch callback parameter should be typed as the safer `unknown` instead of `any`.",
-		secondary: [
-			"TypeScript's `useUnknownInCatchVariables` option only affects synchronous catch clauses, not Promise callbacks.",
-			"Promise rejection values can be anything, so using `unknown` forces proper type narrowing before use.",
-			"Using `any` in catch callbacks undermines type safety and can lead to runtime errors."
-		],
-		suggestions: ["Add an explicit `: unknown` type annotation to the callback parameter."]
-	} },
-	setup(context) {
-		function isGlobalPromiseType(type, program) {
-			const symbol = type.getSymbol();
-			if (symbol?.getName() !== "Promise") return false;
-			const declarations = symbol.getDeclarations();
-			if (!declarations) return false;
-			return declarations.some((declaration) => isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration, program));
-		}
-		function isCatchOrThenCallback(node, typeChecker, program) {
-			if (!isPropertyAccessExpression(node.expression)) return;
-			const methodName = node.expression.name.text;
-			if (methodName !== "catch" && methodName !== "then") return;
-			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker), program)) return;
-			return methodName === "catch" ? "catch" : "then";
-		}
-		function checkCallbackParameter(callback, sourceFile, typeChecker) {
-			if (!isFunctionLike(callback) || !callback.parameters.length) return;
-			const firstParameter = callback.parameters[0];
-			if (firstParameter.type) {
-				const paramType = typeChecker.getTypeFromTypeNode(firstParameter.type);
-				if (tsutils.isTypeFlagSet(paramType, TypeFlags.Unknown) || !tsutils.isTypeFlagSet(paramType, TypeFlags.Any)) return;
-			}
-			context.report({
-				message: "preferUnknown",
-				range: {
-					begin: firstParameter.name.getStart(sourceFile),
-					end: firstParameter.type ? firstParameter.type.getEnd() : firstParameter.name.getEnd()
-				}
-			});
-		}
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			switch (isCatchOrThenCallback(node, typeChecker, program)) {
-				case "catch":
-					if (node.arguments.length >= 1) checkCallbackParameter(node.arguments[0], sourceFile, typeChecker);
-					break;
-				case "then":
-					if (node.arguments.length >= 2) checkCallbackParameter(node.arguments[1], sourceFile, typeChecker);
-					break;
-			}
-		} } };
-	}
-});
-//#endregion
-export { catchCallbackTypes_default as default };

package/lib/rules/caughtVariableNames.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces a consistent naming convention for catch clause error variables.";
-    readonly id: "caughtVariableNames";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferErrorName", undefined>;
-export default _default;