@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/restrictedImports.js

@@ -1,164 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getSpecifierNames } from "../type-utils/getSpecifierNames.js";
-import { matchesSpecifier } from "../type-utils/matchesSpecifier.js";
-import { typeOrValueSpecifierSchema } from "../type-utils/schemas.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/restrictedImports.ts
-const restrictionSchema = z$1.object({
-	allowTypeImports: z$1.boolean().optional().describe("Whether type-only imports are exempt from the restriction."),
-	message: z$1.string().optional().describe("A custom message to display when the restriction is triggered."),
-	specifier: typeOrValueSpecifierSchema.describe("A TypeOrValueSpecifier identifying the restricted import.")
-});
-function resolveModuleDeclarations(moduleSpecifier, typeChecker) {
-	return typeChecker.getSymbolAtLocation(moduleSpecifier)?.getDeclarations();
-}
-function resolveSymbolDeclarations(nameNode, typeChecker) {
-	let symbol = typeChecker.getSymbolAtLocation(nameNode);
-	if (!symbol) return;
-	if (symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
-	return symbol.getDeclarations();
-}
-var restrictedImports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Restricts specified modules from being imported.",
-		id: "restrictedImports"
-	},
-	messages: {
-		moduleRestricted: {
-			primary: "'{{ source }}' import is restricted.",
-			secondary: ["This module has been restricted by project configuration."],
-			suggestions: ["Remove this import or replace it with an allowed alternative."]
-		},
-		moduleRestrictedWithMessage: {
-			primary: "'{{ source }}' import is restricted. {{ customMessage }}",
-			secondary: ["This module has been restricted by project configuration."],
-			suggestions: ["Remove this import or replace it with an allowed alternative."]
-		},
-		namespaceRestricted: {
-			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted.",
-			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
-			suggestions: ["Replace the namespace import with named imports that are allowed."]
-		},
-		namespaceRestrictedWithMessage: {
-			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted. {{ customMessage }}",
-			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
-			suggestions: ["Replace the namespace import with named imports that are allowed."]
-		},
-		restricted: {
-			primary: "'{{ importName }}' import from '{{ source }}' is restricted.",
-			secondary: ["This import name has been restricted by project configuration."],
-			suggestions: ["Remove this import or replace it with an allowed alternative."]
-		},
-		restrictedWithMessage: {
-			primary: "'{{ importName }}' import from '{{ source }}' is restricted. {{ customMessage }}",
-			secondary: ["This import name has been restricted by project configuration."],
-			suggestions: ["Remove this import or replace it with an allowed alternative."]
-		}
-	},
-	options: { restrictions: z$1.array(restrictionSchema).default([]).describe("Restrictions on imports, using TypeOrValueSpecifier to identify targets.") },
-	setup(context) {
-		function checkNamedRestrictions(restrictions, declarations, importedName, isTypeOnly, source, range, program) {
-			for (const restriction of restrictions) {
-				if (restriction.allowTypeImports && isTypeOnly) continue;
-				if (matchesSpecifier(importedName, declarations, restriction.specifier, program)) context.report({
-					data: {
-						customMessage: restriction.message ?? "",
-						importName: importedName,
-						source
-					},
-					message: restriction.message ? "restrictedWithMessage" : "restricted",
-					range
-				});
-			}
-		}
-		function checkWildcardRestrictions(restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program) {
-			for (const restriction of restrictions) {
-				if (restriction.allowTypeImports && topLevelTypeOnly) continue;
-				const names = getSpecifierNames(restriction.specifier);
-				if (names !== void 0) {
-					if (matchesSpecifier(void 0, moduleDeclarations, {
-						...restriction.specifier,
-						name: void 0
-					}, program)) context.report({
-						data: {
-							customMessage: restriction.message ?? "",
-							restrictedNames: names.join("', '"),
-							source
-						},
-						message: restriction.message ? "namespaceRestrictedWithMessage" : "namespaceRestricted",
-						range
-					});
-				} else if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
-					data: {
-						customMessage: restriction.message ?? "",
-						source
-					},
-					message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
-					range
-				});
-			}
-		}
-		return { visitors: {
-			ExportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
-				if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) return;
-				const source = node.moduleSpecifier.text;
-				const topLevelTypeOnly = node.isTypeOnly;
-				const range = getTSNodeRange(node, sourceFile);
-				if (node.exportClause && ts.isNamedExports(node.exportClause)) for (const element of node.exportClause.elements) {
-					const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
-					const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-					const declarations = resolveSymbolDeclarations(element.name, typeChecker);
-					if (!declarations?.length) continue;
-					checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
-				}
-				else {
-					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
-					if (!moduleDeclarations?.length) return;
-					checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
-				}
-			},
-			ImportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
-				if (!ts.isStringLiteral(node.moduleSpecifier)) return;
-				const source = node.moduleSpecifier.text;
-				const range = getTSNodeRange(node, sourceFile);
-				if (!node.importClause) {
-					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
-					if (!moduleDeclarations?.length) return;
-					for (const restriction of options.restrictions) if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
-						data: {
-							customMessage: restriction.message ?? "",
-							source
-						},
-						message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
-						range
-					});
-					return;
-				}
-				const topLevelTypeOnly = node.importClause.phaseModifier === SyntaxKind.TypeKeyword;
-				if (node.importClause.name) {
-					const declarations = resolveSymbolDeclarations(node.importClause.name, typeChecker);
-					if (declarations?.length) checkNamedRestrictions(options.restrictions, declarations, "default", topLevelTypeOnly, source, range, program);
-				}
-				const bindings = node.importClause.namedBindings;
-				if (!bindings) return;
-				if (ts.isNamedImports(bindings)) {
-					for (const element of bindings.elements) {
-						const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
-						const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-						const declarations = resolveSymbolDeclarations(element.name, typeChecker);
-						if (!declarations?.length) continue;
-						checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
-					}
-					return;
-				}
-				const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
-				if (!moduleDeclarations?.length) return;
-				checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
-			}
-		} };
-	}
-});
-//#endregion
-export { restrictedImports_default as default };

package/lib/rules/returnAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using assignment expressions in return statements.";
-    readonly id: "returnAssignments";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noReturnAssign", undefined>;
-export default _default;

package/lib/rules/returnAssignments.js

@@ -1,36 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/returnAssignments.ts
-var returnAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using assignment expressions in return statements.",
-		id: "returnAssignments",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { noReturnAssign: {
-		primary: "Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
-		secondary: ["Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.", "Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear."],
-		suggestions: ["Perform the assignment on a separate line before the return statement."]
-	} },
-	setup(context) {
-		function checkForAssignment(node, sourceFile) {
-			const unwrapped = unwrapParenthesizedNode(node);
-			if (unwrapped.kind === SyntaxKind.BinaryExpression && tsutils.isAssignmentKind(unwrapped.operatorToken.kind)) context.report({
-				message: "noReturnAssign",
-				range: getTSNodeRange(unwrapped.operatorToken, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: (node, { sourceFile }) => {
-				if (node.body.kind !== SyntaxKind.Block) checkForAssignment(node.body, sourceFile);
-			},
-			ReturnStatement: (node, { sourceFile }) => {
-				if (node.expression) checkForAssignment(node.expression, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { returnAssignments_default as default };

package/lib/rules/returnThisTypes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforce that `this` is used when only `this` type is returned.";
-    readonly id: "returnThisTypes";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferThis", undefined>;
-export default _default;

package/lib/rules/returnThisTypes.js

@@ -1,92 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { forEachReturnStatement } from "./utils/forEachReturnStatement.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/returnThisTypes.ts
-var returnThisTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforce that `this` is used when only `this` type is returned.",
-		id: "returnThisTypes",
-		presets: ["logical"]
-	},
-	messages: { preferThis: {
-		primary: "Prefer `this` as the return type instead of the class name for polymorphic chaining.",
-		secondary: [
-			"Annotating this method as returning the class extends to sub-classes as well.",
-			"Any sub-class will be implicitly typed as returning this parent class, rather than itself.",
-			"Using `this` preserves method chaining behavior in subclasses."
-		],
-		suggestions: ["Replace the class name with `this`."]
-	} },
-	setup(context) {
-		function checkFunction(functionNode, originalClassNode, { sourceFile, typeChecker }) {
-			if (originalClassNode.kind !== ts$1.SyntaxKind.ClassDeclaration && originalClassNode.kind !== ts$1.SyntaxKind.ClassExpression) return;
-			const className = originalClassNode.name?.text;
-			if (!className || !functionNode.type) return;
-			const nameNode = tryGetNameInType(className, functionNode.type);
-			if (!nameNode || !isFunctionReturningThis(functionNode, originalClassNode, typeChecker)) return;
-			const range = getTSNodeRange(nameNode, sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: "this"
-				},
-				message: "preferThis",
-				range
-			});
-		}
-		function isFunctionReturningThis(functionNode, originalClassNode, typeChecker) {
-			if (!functionNode.body || isThisSpecifiedInParameters(functionNode)) return false;
-			const classType = typeChecker.getTypeAtLocation(originalClassNode);
-			if (functionNode.body.kind !== ts$1.SyntaxKind.Block) return classType.thisType === typeChecker.getTypeAtLocation(functionNode.body);
-			let hasReturnThis = false;
-			let hasReturnClassType = false;
-			forEachReturnStatement(functionNode.body, (statement) => {
-				if (!statement.expression) return;
-				if (statement.expression.kind === ts$1.SyntaxKind.ThisKeyword) {
-					hasReturnThis = true;
-					return;
-				}
-				const type = typeChecker.getTypeAtLocation(statement.expression);
-				if (classType === type) {
-					hasReturnClassType = true;
-					return true;
-				}
-				if (classType.thisType === type) {
-					hasReturnThis = true;
-					return;
-				}
-				if (tsutils.isUnionType(type) && type.types.includes(classType)) {
-					hasReturnClassType = true;
-					return true;
-				}
-			});
-			return !hasReturnClassType && hasReturnThis;
-		}
-		function isThisSpecifiedInParameters(functionNode) {
-			if (!functionNode.parameters.length) return false;
-			const firstArgument = functionNode.parameters[0];
-			return ts$1.isIdentifier(firstArgument.name) && firstArgument.name.text === "this";
-		}
-		function tryGetNameInType(name, typeNode) {
-			if (ts$1.isTypeReferenceNode(typeNode) && ts$1.isIdentifier(typeNode.typeName) && typeNode.typeName.text === name) return typeNode;
-			if (ts$1.isUnionTypeNode(typeNode)) for (const type of typeNode.types) {
-				const found = tryGetNameInType(name, type);
-				if (found) return found;
-			}
-		}
-		function checkMethodLike(node, services) {
-			checkFunction(node, node.parent, services);
-		}
-		return { visitors: {
-			GetAccessor: checkMethodLike,
-			MethodDeclaration: checkMethodLike,
-			PropertyDeclaration(node, services) {
-				if (node.initializer && (ts$1.isFunctionExpression(node.initializer) || ts$1.isArrowFunction(node.initializer))) checkFunction(node.initializer, node.parent, services);
-			}
-		} };
-	}
-});
-//#endregion
-export { returnThisTypes_default as default };

package/lib/rules/ruleCreator.d.ts

@@ -1,2 +0,0 @@
-import { RuleCreator } from "@flint.fyi/core";
-export declare const ruleCreator: RuleCreator<"javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict", import("@flint.fyi/core").RuleAbout<"javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict">>;

package/lib/rules/ruleCreator.js

@@ -1,15 +0,0 @@
-import { RuleCreator } from "@flint.fyi/core";
-//#region src/rules/ruleCreator.ts
-const ruleCreator = new RuleCreator({
-	docs: (ruleId) => `https://flint.fyi/rules/ts/${ruleId.toLowerCase()}`,
-	pluginId: "ts",
-	presets: [
-		"javascript",
-		"logical",
-		"logicalStrict",
-		"stylistic",
-		"stylisticStrict"
-	]
-});
-//#endregion
-export { ruleCreator };

package/lib/rules/selfAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports self-assignments which have no effect and are likely errors.";
-    readonly id: "selfAssignments";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "selfAssignment", undefined>;
-export default _default;

package/lib/rules/selfAssignments.js

@@ -1,27 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/selfAssignments.ts
-var selfAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports self-assignments which have no effect and are likely errors.",
-		id: "selfAssignments",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { selfAssignment: {
-		primary: "This value is being assigned to itself, which does nothing.",
-		secondary: ["Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error."],
-		suggestions: ["Review the assignment and ensure you're assigning the correct value."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind !== SyntaxKind.EqualsToken && node.operatorToken.kind !== SyntaxKind.AmpersandAmpersandEqualsToken && node.operatorToken.kind !== SyntaxKind.BarBarEqualsToken && node.operatorToken.kind !== SyntaxKind.QuestionQuestionEqualsToken) return;
-			if (hasSameTokens(node.left, node.right, sourceFile)) context.report({
-				message: "selfAssignment",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { selfAssignments_default as default };

package/lib/rules/sequences.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the comma operator in expressions.";
-    readonly id: "sequences";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noSequences", undefined>;
-export default _default;

package/lib/rules/sequences.js

@@ -1,26 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/sequences.ts
-var sequences_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the comma operator in expressions.",
-		id: "sequences",
-		presets: ["javascript"]
-	},
-	messages: { noSequences: {
-		primary: "The \"sequence\" (comma) operator is often confusing and a sign of mistaken logic.",
-		secondary: ["The comma operator can make code harder to read and may hide side effects.", "Prefer separate expressions instead of using a single sequence."],
-		suggestions: ["Split the expression into separate statements."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind === SyntaxKind.CommaToken) context.report({
-				message: "noSequences",
-				range: getTSNodeRange(node.operatorToken, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { sequences_default as default };

package/lib/rules/setSizeLengthChecks.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer `Set.size` over spreading into an array and accessing `.length`.";
-    readonly id: "setSizeLengthChecks";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSize", undefined>;
-export default _default;

package/lib/rules/setSizeLengthChecks.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { NodeFlags, SyntaxKind, isArrayLiteralExpression, isIdentifier, isNewExpression, isParenthesizedExpression, isSpreadElement, isVariableDeclaration } from "typescript";
-//#region src/rules/setSizeLengthChecks.ts
-function isNewSetExpression(expression, typeChecker, program) {
-	return isNewExpression(expression) && isIdentifier(expression.expression) && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker, program);
-}
-function isSetExpression(expression, typeChecker, program) {
-	const unwrapped = unwrapParentheses(expression);
-	if (isNewSetExpression(unwrapped, typeChecker, program)) return true;
-	if (!isIdentifier(unwrapped)) return false;
-	const symbol = typeChecker.getSymbolAtLocation(unwrapped);
-	if (!symbol?.valueDeclaration || !isVariableDeclaration(symbol.valueDeclaration)) return false;
-	const declaration = symbol.valueDeclaration;
-	if (declaration.parent.kind !== SyntaxKind.VariableDeclarationList || !(declaration.parent.flags & NodeFlags.Const) || !declaration.initializer) return false;
-	return isNewSetExpression(unwrapParentheses(declaration.initializer), typeChecker, program);
-}
-function unwrapParentheses(expression) {
-	while (isParenthesizedExpression(expression)) expression = expression.expression;
-	return expression;
-}
-var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer `Set.size` over spreading into an array and accessing `.length`.",
-		id: "setSizeLengthChecks",
-		presets: ["logical"]
-	},
-	messages: { preferSize: {
-		primary: "Prefer `Set.size` instead of spreading into an array and accessing `.length`.",
-		secondary: ["`Set` has a built-in `.size` property that directly returns the number of elements.", "It is faster and more idiomatic to use that instead of creating an intermediate array."],
-		suggestions: ["Use `.size` directly on the `Set` instead."]
-	} },
-	setup(context) {
-		return { visitors: { PropertyAccessExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.questionDotToken || node.name.text !== "length" || !isArrayLiteralExpression(node.expression) || node.expression.elements.length !== 1) return;
-			const element = node.expression.elements[0];
-			if (!isSpreadElement(element) || !isSetExpression(element.expression, typeChecker, program)) return;
-			context.report({
-				message: "preferSize",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { setSizeLengthChecks_default as default };

package/lib/rules/setterReturns.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports return statements with values inside setters.";
-    readonly id: "setterReturns";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noSetterReturn", undefined>;
-export default _default;

package/lib/rules/setterReturns.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/setterReturns.ts
-var setterReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports return statements with values inside setters.",
-		id: "setterReturns",
-		presets: ["javascript"]
-	},
-	messages: { noSetterReturn: {
-		primary: "Values returned by setters are always ignored.",
-		secondary: ["Setters are expected to have side effects only and not produce a return value.", "Any returned value from a setter is ignored."],
-		suggestions: ["Remove the return value.", "Use a regular method instead."]
-	} },
-	setup(context) {
-		return { visitors: { SetAccessor: (node, { sourceFile }) => {
-			if (!node.body) return;
-			function checkForReturnStatements(node) {
-				if (ts.isReturnStatement(node)) {
-					if (node.expression) context.report({
-						message: "noSetterReturn",
-						range: {
-							begin: node.getStart(sourceFile),
-							end: node.getEnd()
-						}
-					});
-					return;
-				}
-				if (tsutils.isFunctionScopeBoundary(node)) return;
-				ts.forEachChild(node, checkForReturnStatements);
-			}
-			ts.forEachChild(node.body, checkForReturnStatements);
-		} } };
-	}
-});
-//#endregion
-export { setterReturns_default as default };

package/lib/rules/shadowedRestrictedNames.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
-    readonly id: "shadowedRestrictedNames";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "shadowedRestrictedName", undefined>;
-export default _default;

package/lib/rules/shadowedRestrictedNames.js

@@ -1,66 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/shadowedRestrictedNames.ts
-const restrictedNames = /* @__PURE__ */ new Set([
-	"arguments",
-	"eval",
-	"Infinity",
-	"NaN",
-	"undefined"
-]);
-var shadowedRestrictedNames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports variable declarations that shadow JavaScript's restricted names.",
-		id: "shadowedRestrictedNames",
-		presets: ["javascript"]
-	},
-	messages: { shadowedRestrictedName: {
-		primary: "This variable misleadingly shadows the global `{{ name }}`.",
-		secondary: ["JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.", "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior."],
-		suggestions: ["Use a different variable name that doesn't shadow a restricted name."]
-	} },
-	setup(context) {
-		function checkIdentifier(node, sourceFile) {
-			if (restrictedNames.has(node.text)) context.report({
-				data: { name: node.text },
-				message: "shadowedRestrictedName",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		function checkBindingName(name, sourceFile) {
-			if (name.kind === SyntaxKind.Identifier) checkIdentifier(name, sourceFile);
-			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) checkBindingName(element.name, sourceFile);
-		}
-		function checkParameters(parameters, sourceFile) {
-			for (const parameter of parameters) checkBindingName(parameter.name, sourceFile);
-		}
-		return { visitors: {
-			ArrowFunction: (node, { sourceFile }) => {
-				checkParameters(node.parameters, sourceFile);
-			},
-			ClassDeclaration: (node, { sourceFile }) => {
-				if (node.name) checkIdentifier(node.name, sourceFile);
-			},
-			ClassExpression: (node, { sourceFile }) => {
-				if (node.name) checkIdentifier(node.name, sourceFile);
-			},
-			FunctionDeclaration: (node, { sourceFile }) => {
-				if (node.name) checkIdentifier(node.name, sourceFile);
-				checkParameters(node.parameters, sourceFile);
-			},
-			FunctionExpression: (node, { sourceFile }) => {
-				if (node.name) checkIdentifier(node.name, sourceFile);
-				checkParameters(node.parameters, sourceFile);
-			},
-			MethodDeclaration: (node, { sourceFile }) => {
-				checkParameters(node.parameters, sourceFile);
-			},
-			VariableDeclaration: (node, { sourceFile }) => {
-				checkBindingName(node.name, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { shadowedRestrictedNames_default as default };

package/lib/rules/singleVariableDeclarations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces one variable per declaration statement.";
-    readonly id: "singleVariableDeclarations";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "singleVariable", undefined>;
-export default _default;

package/lib/rules/singleVariableDeclarations.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/singleVariableDeclarations.ts
-var singleVariableDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces one variable per declaration statement.",
-		id: "singleVariableDeclarations",
-		presets: ["logical"]
-	},
-	messages: { singleVariable: {
-		primary: "Split this into separate variable declarations.",
-		secondary: ["Declaring multiple variables in one statement can reduce readability."],
-		suggestions: ["Use separate declaration statements for each variable."]
-	} },
-	setup(context) {
-		return { visitors: {
-			ForStatement: (node, { sourceFile }) => {
-				if (node.initializer && ts.isVariableDeclarationList(node.initializer) && node.initializer.declarations.length > 1) context.report({
-					message: "singleVariable",
-					range: getTSNodeRange(node.initializer, sourceFile)
-				});
-			},
-			VariableStatement: (node, { sourceFile }) => {
-				if (node.declarationList.declarations.length > 1) context.report({
-					message: "singleVariable",
-					range: getTSNodeRange(node.declarationList, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { singleVariableDeclarations_default as default };

package/lib/rules/sizeComparisonOperators.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforce consistent style for `.length` and `.size` checks.";
-    readonly id: "sizeComparisonOperators";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "coercionNonZeroCheck" | "coercionZeroCheck" | "explicitNonZeroCheck" | "explicitZeroCheck", {
-    style: z.ZodDefault<z.ZodEnum<{
-        coercion: "coercion";
-        explicit: "explicit";
-    }>>;
-}>;
-export default _default;