@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/assignmentOperatorShorthands.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/assignmentOperatorShorthands.ts
-var assignmentOperatorShorthands_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer logical assignment operator shorthand expressions.",
-		id: "assignmentOperatorShorthands",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferShorthand: {
-		primary: "Prefer the logical assignment operator shorthand `{{ operator }}`.",
-		secondary: ["Logical assignment operators are more concise and express the intent more clearly.", "They were introduced in ES2021 and are supported in all modern environments."],
-		suggestions: ["Use the shorthand operator `{{ operator }}`."]
-	} },
-	setup(context) {
-		function getShorthand(kind) {
-			switch (kind) {
-				case ts$1.SyntaxKind.AmpersandAmpersandToken: return "&&=";
-				case ts$1.SyntaxKind.BarBarToken: return "||=";
-				case ts$1.SyntaxKind.QuestionQuestionToken: return "??=";
-				default: return;
-			}
-		}
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || !ts$1.isBinaryExpression(node.right)) return;
-			const shorthand = getShorthand(node.right.operatorToken.kind);
-			if (!shorthand) return;
-			if (!hasSameTokens(node.left, node.right.left, sourceFile)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			const fixedText = `${node.left.getText(sourceFile)} ${shorthand} ${node.right.right.getText(sourceFile)}`;
-			context.report({
-				data: { operator: shorthand },
-				fix: {
-					range,
-					text: fixedText
-				},
-				message: "preferShorthand",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { assignmentOperatorShorthands_default as default };
-
-//# sourceMappingURL=assignmentOperatorShorthands.js.map

package/lib/rules/asyncFunctionAwaits.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports async functions that do not use await.";
-    readonly id: "asyncFunctionAwaits";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingAwait", undefined>;
-export default _default;
-//# sourceMappingURL=asyncFunctionAwaits.d.ts.map

package/lib/rules/asyncFunctionAwaits.js

@@ -1,55 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/asyncFunctionAwaits.ts
-var asyncFunctionAwaits_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports async functions that do not use await.",
-		id: "asyncFunctionAwaits",
-		presets: ["logicalStrict"]
-	},
-	messages: { missingAwait: {
-		primary: "This function is marked `async` but does not contain an `await` expression or return a Promise.",
-		secondary: ["Async functions always wrap their return value in a Promise, which adds overhead if you're not using await.", "This may indicate incomplete implementation or leftover code after refactoring."],
-		suggestions: ["Add an `await` expression if you need to wait for asynchronous operations.", "Remove the `async` keyword if the function doesn't need to be asynchronous."]
-	} },
-	setup(context) {
-		function checkFunction(node, { sourceFile, typeChecker }) {
-			const asyncModifier = node.modifiers?.find((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
-			if (!asyncModifier || node.asteriskToken || !node.body || isEmptyBody(node.body) || checkForAwait(node.body) || bodyReturnsThenable(node.body, typeChecker)) return;
-			context.report({
-				message: "missingAwait",
-				range: getTSNodeRange(asyncModifier, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: checkFunction,
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-			MethodDeclaration: checkFunction
-		} };
-	}
-});
-function bodyReturnsThenable(body, typeChecker) {
-	if (!ts$1.isBlock(body)) return tsutils.isThenableType(typeChecker, body);
-	function checkReturnStatements(node) {
-		if (ts$1.isReturnStatement(node) && node.expression && tsutils.isThenableType(typeChecker, node.expression)) return true;
-		if (tsutils.isFunctionScopeBoundary(node)) return false;
-		return ts$1.forEachChild(node, checkReturnStatements);
-	}
-	return ts$1.forEachChild(body, checkReturnStatements);
-}
-function checkForAwait(node) {
-	if (ts$1.isAwaitExpression(node)) return true;
-	if (ts$1.isForOfStatement(node) && node.awaitModifier) return true;
-	if (tsutils.isFunctionScopeBoundary(node)) return false;
-	return ts$1.forEachChild(node, checkForAwait);
-}
-function isEmptyBody(body) {
-	return ts$1.isBlock(body) && !body.statements.length;
-}
-//#endregion
-export { asyncFunctionAwaits_default as default };
-
-//# sourceMappingURL=asyncFunctionAwaits.js.map

package/lib/rules/asyncPromiseExecutors.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using async functions as Promise executor functions.";
-    readonly id: "asyncPromiseExecutors";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "asyncPromiseExecutor", undefined>;
-export default _default;
-//# sourceMappingURL=asyncPromiseExecutors.d.ts.map

package/lib/rules/asyncPromiseExecutors.js

@@ -1,41 +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, { sourceFile, typeChecker }) => {
-			if (!isGlobalDeclaration(node.expression, typeChecker) || !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 };
-
-//# sourceMappingURL=asyncPromiseExecutors.js.map

package/lib/rules/asyncUnnecessaryPromiseWrappers.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=asyncUnnecessaryPromiseWrappers.d.ts.map

package/lib/rules/asyncUnnecessaryPromiseWrappers.js

@@ -1,52 +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 };
-
-//# sourceMappingURL=asyncUnnecessaryPromiseWrappers.js.map

package/lib/rules/atAccesses.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=atAccesses.d.ts.map

package/lib/rules/atAccesses.js

@@ -1,52 +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 };
-
-//# sourceMappingURL=atAccesses.js.map

package/lib/rules/builtinCoercions.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=builtinCoercions.d.ts.map

package/lib/rules/builtinCoercions.js

@@ -1,117 +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 = new Set([
-	"BigInt",
-	"Boolean",
-	"Number",
-	"String",
-	"Symbol"
-]);
-const arrayMethodsWithBooleanCallback = 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 };
-
-//# sourceMappingURL=builtinCoercions.js.map

package/lib/rules/builtinConstructorNews.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=builtinConstructorNews.d.ts.map

package/lib/rules/builtinConstructorNews.js

@@ -1,89 +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 = 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 = 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, { 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)) 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 };
-
-//# sourceMappingURL=builtinConstructorNews.js.map

package/lib/rules/caseDeclarations.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=caseDeclarations.d.ts.map

package/lib/rules/caseDeclarations.js

@@ -1,40 +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 };
-
-//# sourceMappingURL=caseDeclarations.js.map

package/lib/rules/caseDuplicates.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=caseDuplicates.d.ts.map

package/lib/rules/caseDuplicates.js

@@ -1,36 +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 };
-
-//# sourceMappingURL=caseDuplicates.js.map

package/lib/rules/caseFallthroughs.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=caseFallthroughs.d.ts.map