@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/forDirections.js

@@ -1,73 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/forDirections.ts
-function getConditionDirection(condition, counterName) {
-	if (condition.kind !== SyntaxKind.BinaryExpression) return;
-	const leftName = getCounterName(condition.left);
-	const rightName = getCounterName(condition.right);
-	if (!leftName && !rightName) return condition.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken ? getConditionDirection(condition.left, counterName) ?? getConditionDirection(condition.right, counterName) : void 0;
-	const isCounterLeft = leftName === counterName;
-	if (!isCounterLeft && !(rightName === counterName)) return;
-	const { operatorToken } = condition;
-	if (isCounterLeft) {
-		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return 1;
-		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return -1;
-	} else {
-		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return -1;
-		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return 1;
-	}
-}
-function getCounterName(node) {
-	return node.kind === SyntaxKind.Identifier ? node.text : void 0;
-}
-function getIncrementorDirection(incrementor) {
-	if (incrementor.kind === SyntaxKind.PostfixUnaryExpression || incrementor.kind === SyntaxKind.PrefixUnaryExpression) switch (incrementor.operator) {
-		case SyntaxKind.MinusMinusToken: return -1;
-		case SyntaxKind.PlusPlusToken: return 1;
-		default: return;
-	}
-	if (incrementor.kind === SyntaxKind.BinaryExpression) {
-		const { operatorToken, right } = incrementor;
-		if (operatorToken.kind === SyntaxKind.PlusEqualsToken || operatorToken.kind === SyntaxKind.MinusEqualsToken) {
-			if (right.kind === SyntaxKind.NumericLiteral) {
-				const value = Number(right.text);
-				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? 1 : value < 0 ? -1 : 0;
-				return value > 0 ? -1 : value < 0 ? 1 : 0;
-			}
-			if (right.kind === SyntaxKind.PrefixUnaryExpression && right.operator === SyntaxKind.MinusToken && right.operand.kind === SyntaxKind.NumericLiteral) {
-				const value = Number(right.operand.text);
-				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? -1 : 1;
-				return value > 0 ? 1 : -1;
-			}
-		}
-	}
-}
-var forDirections_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports for loops with counter variables that move in the wrong direction.",
-		id: "forDirections",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { wrongDirection: {
-		primary: "The update moves the counter in the wrong direction for this loop condition.",
-		secondary: ["A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.", "When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect."],
-		suggestions: ["Verify the loop counter update direction matches the condition."]
-	} },
-	setup(context) {
-		return { visitors: { ForStatement: (node, { sourceFile }) => {
-			if (!node.condition || !node.incrementor || node.initializer?.kind !== SyntaxKind.VariableDeclarationList) return;
-			const declaration = node.initializer.declarations.at(0);
-			if (declaration?.name.kind !== SyntaxKind.Identifier) return;
-			const updateDirection = getIncrementorDirection(node.incrementor);
-			if (!updateDirection) return;
-			const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
-			if (conditionDirection && conditionDirection !== updateDirection) context.report({
-				message: "wrongDirection",
-				range: getTSNodeRange(node.incrementor, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { forDirections_default as default };

package/lib/rules/forInArrays.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports iterating over an array with a for-in loop.";
-    readonly id: "forInArrays";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "forIn", undefined>;
-export default _default;

package/lib/rules/forInArrays.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { isTypeRecursive } from "./utils/isTypeRecursive.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/forInArrays.ts
-var forInArrays_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports iterating over an array with a for-in loop.",
-		id: "forInArrays",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { forIn: {
-		primary: "For-in loops over arrays have surprising behavior that often leads to bugs.",
-		secondary: [
-			"A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
-			"This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
-			"It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices."
-		],
-		suggestions: ["Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`)."]
-	} },
-	setup(context) {
-		function hasNumberLikeLength(type, typeChecker) {
-			const lengthProperty = type.getProperty("length");
-			if (lengthProperty == null) return false;
-			return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
-		}
-		function isArrayLike(type, typeChecker) {
-			return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
-		}
-		return { visitors: { ForInStatement: (node, { sourceFile, typeChecker }) => {
-			if (isArrayLike(getConstrainedTypeAtLocation(node.expression, typeChecker), typeChecker)) context.report({
-				message: "forIn",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.statement.getStart(sourceFile) - 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { forInArrays_default as default };

package/lib/rules/forInGuards.d.ts

@@ -1,8 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports for-in loops without an if statement to filter inherited properties.";
-    readonly id: "forInGuards";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingGuard", undefined>;
-export default _default;

package/lib/rules/forInGuards.js

@@ -1,42 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/forInGuards.ts
-function isIfStatementGuard(node) {
-	if (ts.isContinueStatement(node.thenStatement)) return true;
-	if (ts.isBlock(node.thenStatement) && node.thenStatement.statements.length === 1 && ts.isContinueStatement(node.thenStatement.statements[0])) return true;
-	return false;
-}
-var forInGuards_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports for-in loops without an if statement to filter inherited properties.",
-		id: "forInGuards"
-	},
-	messages: { missingGuard: {
-		primary: "For-in loop body should be wrapped in an if statement to filter inherited properties.",
-		secondary: ["Looping over objects with a for-in loop will include properties inherited through the prototype chain.", "This behavior can lead to unexpected items being iterated over."],
-		suggestions: ["Wrap the loop body with `if (Object.hasOwn(object, key))` or `if (Object.prototype.hasOwnProperty.call(object, key))`."]
-	} },
-	setup(context) {
-		return { visitors: { ForInStatement: (node, { sourceFile }) => {
-			switch (node.statement.kind) {
-				case ts.SyntaxKind.EmptyStatement:
-				case ts.SyntaxKind.IfStatement: return;
-				case ts.SyntaxKind.Block: {
-					if (!node.statement.statements.length) return;
-					const firstStatement = node.statement.statements[0];
-					if (firstStatement.kind === ts.SyntaxKind.IfStatement && (node.statement.statements.length === 1 || isIfStatementGuard(firstStatement))) return;
-				}
-			}
-			context.report({
-				message: "missingGuard",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.statement.getStart(sourceFile)
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { forInGuards_default as default };

package/lib/rules/functionApplySpreads.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer the spread operator over `.apply()` calls.";
-    readonly id: "functionApplySpreads";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSpread", undefined>;
-export default _default;

package/lib/rules/functionApplySpreads.js

@@ -1,61 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, isFunction, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/functionApplySpreads.ts
-var functionApplySpreads_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer the spread operator over `.apply()` calls.",
-		id: "functionApplySpreads",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferSpread: {
-		primary: "Use the spread operator instead of `.apply()`.",
-		secondary: ["The spread operator (`...`) provides cleaner syntax for variadic function calls.", "`func.apply(thisArg, args)` can be replaced with `func.call(thisArg, ...args)` or `thisArg.func(...args)`."],
-		suggestions: ["Replace `.apply(thisArg, args)` with spread syntax like `func(...args)`."]
-	} },
-	setup(context) {
-		function isNullOrUndefined(node) {
-			return node.kind === SyntaxKind.NullKeyword || node.kind === SyntaxKind.Identifier && node.text === "undefined";
-		}
-		function isApplyCall(node) {
-			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) return false;
-			const propertyAccess = node.expression;
-			if (propertyAccess.name.kind !== SyntaxKind.Identifier) return false;
-			return propertyAccess.name.text === "apply";
-		}
-		function getVariadicArgumentsNode(node) {
-			if (!isApplyCall(node) || node.arguments.length !== 2) return;
-			const argumentsNode = node.arguments[1];
-			if (argumentsNode.kind === SyntaxKind.ArrayLiteralExpression || argumentsNode.kind === SyntaxKind.SpreadElement) return;
-			return argumentsNode;
-		}
-		function getExpectedThis(node) {
-			const applied = node.expression;
-			if (applied.kind === SyntaxKind.PropertyAccessExpression) return applied.expression;
-		}
-		function isValidThisArg(expectedThis, thisArg, sourceFile) {
-			return expectedThis ? hasSameTokens(expectedThis, thisArg, sourceFile) : isNullOrUndefined(thisArg);
-		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			const argumentsNode = getVariadicArgumentsNode(node);
-			if (!argumentsNode) return;
-			if (!ts.isPropertyAccessExpression(node.expression) || !isFunction(node.expression.expression, typeChecker)) return;
-			const expectedThis = getExpectedThis(node.expression);
-			const thisArg = node.arguments[0];
-			if (!isValidThisArg(expectedThis, thisArg, sourceFile)) return;
-			const argumentsText = argumentsNode.getText(sourceFile);
-			const range = getTSNodeRange(node, sourceFile);
-			const fixedText = `${node.expression.expression.getText(sourceFile)}(...${argumentsText})`;
-			context.report({
-				fix: {
-					range,
-					text: fixedText
-				},
-				message: "preferSpread",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { functionApplySpreads_default as default };

package/lib/rules/functionAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports reassigning variables declared with function declarations.";
-    readonly id: "functionAssignments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noFunctionAssignment", undefined>;
-export default _default;

package/lib/rules/functionAssignments.js

@@ -1,27 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/functionAssignments.ts
-var functionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports reassigning variables declared with function declarations.",
-		id: "functionAssignments",
-		presets: ["javascript"]
-	},
-	messages: { noFunctionAssignment: {
-		primary: "Variables declared with function declarations should not be reassigned.",
-		secondary: ["Reassigning a function declaration can make code harder to understand and maintain.", "Function declarations are hoisted to the top of their scope, and reassigning them can lead to unexpected behavior."],
-		suggestions: ["Use a function expression or const variable instead if you need to reassign the function."]
-	} },
-	setup(context) {
-		return { visitors: { FunctionDeclaration: (node, { sourceFile }) => {
-			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
-			for (const reference of modifyingReferences) context.report({
-				message: "noFunctionAssignment",
-				range: getTSNodeRange(reference, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { functionAssignments_default as default };

package/lib/rules/functionCurryingRedundancy.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
-    readonly id: "functionCurryingRedundancy";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryCall", undefined>;
-export default _default;

package/lib/rules/functionCurryingRedundancy.js

@@ -1,51 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isFunction, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/functionCurryingRedundancy.ts
-var functionCurryingRedundancy_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.",
-		id: "functionCurryingRedundancy",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unnecessaryCall: {
-		primary: "This \"currying\" of a function without a defined context does nothing and can be simplified.",
-		secondary: ["Using `.{{ method }}()` with null or undefined as the context provides no benefit over a direct function call.", "This adds unnecessary complexity and reduces code readability."],
-		suggestions: ["Replace the `.{{ method }}()` with a direct function call."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) return;
-			const method = node.expression.name.text;
-			if (method !== "call" && method !== "apply" || !node.arguments.length || !isFunction(node.expression.expression, typeChecker)) return;
-			const firstArgument = nullThrows(node.arguments[0], "First argument is expected to be present by prior length check");
-			if (firstArgument.kind !== SyntaxKind.NullKeyword && !(firstArgument.kind === SyntaxKind.Identifier && firstArgument.text === "undefined")) return;
-			const fixTextCreator = method === "apply" ? createApplyFixText : createCallFixText;
-			context.report({
-				data: { method },
-				fix: {
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					},
-					text: fixTextCreator(node.expression.expression.getText(sourceFile), node.arguments.slice(1), sourceFile)
-				},
-				message: "unnecessaryCall",
-				range: {
-					begin: node.expression.name.getStart(sourceFile) - 1,
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function createApplyFixText(functionExpression, methodArguments, sourceFile) {
-	if (!methodArguments.length) return `${functionExpression}()`;
-	return `${functionExpression}(...${nullThrows(methodArguments[0], "First argument is expected to be present by prior length check").getText(sourceFile)})`;
-}
-function createCallFixText(functionExpression, methodArguments, sourceFile) {
-	return `${functionExpression}(${methodArguments.map((arg) => arg.getText(sourceFile)).join(", ")})`;
-}
-//#endregion
-export { functionCurryingRedundancy_default as default };

package/lib/rules/functionDeclarationStyles.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports functions that don't match the configured style (declaration vs expression).";
-    readonly id: "functionDeclarationStyles";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferDeclaration" | "preferExpression", {
-    allowArrowFunctions: z.ZodDefault<z.ZodBoolean>;
-    style: z.ZodDefault<z.ZodEnum<{
-        expression: "expression";
-        declaration: "declaration";
-    }>>;
-}>;
-export default _default;

package/lib/rules/functionDeclarationStyles.js

@@ -1,65 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/functionDeclarationStyles.ts
-function isOverloadedDeclaration(node, sourceFile) {
-	if (!node.name) return false;
-	const statements = sourceFile.statements;
-	let count = 0;
-	for (const statement of statements) if (ts.isFunctionDeclaration(statement) && statement.name?.text === node.name.text) {
-		count++;
-		if (count > 1) return true;
-	}
-	return false;
-}
-var functionDeclarationStyles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports functions that don't match the configured style (declaration vs expression).",
-		id: "functionDeclarationStyles"
-	},
-	messages: {
-		preferDeclaration: {
-			primary: "For consistency, this project prefers a function declaration instead of a function expression.",
-			secondary: ["Function declarations are hoisted and provide clearer intent for named functions."],
-			suggestions: ["Convert this function expression to a function declaration."]
-		},
-		preferExpression: {
-			primary: "For consistency, this project prefers a function expression instead of a function declaration.",
-			secondary: ["Function expressions assigned to variables provide consistent syntax with arrow functions."],
-			suggestions: ["Convert this function declaration to a function expression assigned to a variable."]
-		}
-	},
-	options: {
-		allowArrowFunctions: z$1.boolean().default(false).describe("Whether to allow arrow functions when style is 'declaration'."),
-		style: z$1.enum(["declaration", "expression"]).default("expression").describe("Which function style to enforce: 'declaration' for function declarations or 'expression' for function expressions.")
-	},
-	setup(context) {
-		return { visitors: {
-			FunctionDeclaration: (node, { options, sourceFile }) => {
-				if (options.style !== "expression" || !node.name || isOverloadedDeclaration(node, sourceFile)) return;
-				context.report({
-					message: "preferExpression",
-					range: getTSNodeRange(node.name, sourceFile)
-				});
-			},
-			VariableStatement: (node, { options, sourceFile }) => {
-				if (options.style !== "declaration") return;
-				for (const declaration of node.declarationList.declarations) switch (declaration.initializer?.kind) {
-					case ts.SyntaxKind.ArrowFunction:
-						if (!options.allowArrowFunctions) context.report({
-							message: "preferDeclaration",
-							range: getTSNodeRange(declaration.name, sourceFile)
-						});
-						break;
-					case ts.SyntaxKind.FunctionExpression: context.report({
-						message: "preferDeclaration",
-						range: getTSNodeRange(declaration.name, sourceFile)
-					});
-				}
-			}
-		} };
-	}
-});
-//#endregion
-export { functionDeclarationStyles_default as default };

package/lib/rules/functionNameMatches.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports function names that don't match the variable or property they're assigned to.";
-    readonly id: "functionNameMatches";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "mismatch", undefined>;
-export default _default;

package/lib/rules/functionNameMatches.js

@@ -1,72 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/functionNameMatches.ts
-function getNameText(name) {
-	return ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) ? name.text : void 0;
-}
-function getNameTextIfMismatched(functionName, name) {
-	const nameText = getNameText(name);
-	if (!nameText || nameText === functionName || !isValidIdentifier(nameText)) return;
-	return nameText;
-}
-function isValidIdentifier(name) {
-	return /^[\p{L}_$][\p{L}\d_$]*$/u.test(name);
-}
-var functionNameMatches_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports function names that don't match the variable or property they're assigned to.",
-		id: "functionNameMatches",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { mismatch: {
-		primary: "Function name `{{ functionName }}` does not match assigned name `{{ assignedName }}`.",
-		secondary: ["When a named function expression is assigned to a variable or property, the function name should match to avoid confusion."],
-		suggestions: ["Rename the function to `{{ assignedName }}`", "Use an anonymous function."]
-	} },
-	setup(context) {
-		return { visitors: {
-			PropertyAssignment: (node, { sourceFile }) => {
-				if (!ts.isFunctionExpression(node.initializer) || !node.initializer.name) return;
-				const propertyName = getNameTextIfMismatched(node.initializer.name.text, node.name);
-				if (!propertyName) return;
-				context.report({
-					data: {
-						assignedName: propertyName,
-						functionName: node.initializer.name.text
-					},
-					message: "mismatch",
-					range: getTSNodeRange(node.initializer.name, sourceFile)
-				});
-			},
-			PropertyDeclaration: (node, { sourceFile }) => {
-				if (!node.initializer || !ts.isFunctionExpression(node.initializer) || node.name.kind !== ts.SyntaxKind.Identifier || !node.initializer.name) return;
-				const propertyName = getNameTextIfMismatched(node.initializer.name.text, node.name);
-				if (!propertyName) return;
-				context.report({
-					data: {
-						assignedName: propertyName,
-						functionName: node.initializer.name.text
-					},
-					message: "mismatch",
-					range: getTSNodeRange(node.initializer.name, sourceFile)
-				});
-			},
-			VariableDeclaration: (node, { sourceFile }) => {
-				if (!node.initializer || !ts.isFunctionExpression(node.initializer) || !node.initializer.name || !ts.isIdentifier(node.name)) return;
-				const variableName = getNameTextIfMismatched(node.initializer.name.text, node.name);
-				if (!variableName) return;
-				context.report({
-					data: {
-						assignedName: variableName,
-						functionName: node.initializer.name.text
-					},
-					message: "mismatch",
-					range: getTSNodeRange(node.initializer.name, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { functionNameMatches_default as default };

package/lib/rules/functionNewCalls.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the Function constructor to create functions from strings.";
-    readonly id: "functionNewCalls";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noFunctionConstructor", undefined>;
-export default _default;

package/lib/rules/functionNewCalls.js

@@ -1,40 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/functionNewCalls.ts
-var functionNewCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the Function constructor to create functions from strings.",
-		id: "functionNewCalls",
-		presets: ["logical"]
-	},
-	messages: { noFunctionConstructor: {
-		primary: "Dynamically creating functions with the Function constructor is insecure and slow.",
-		secondary: ["Using the `Function` constructor to create functions from strings is similar to `eval()` and introduces security risks and performance issues.", "Code passed to the Function constructor is executed in the global scope, making it harder to optimize and potentially allowing arbitrary code execution if user input is involved."],
-		suggestions: ["Define functions using function declarations (`function name() {}`) or arrow functions (`() => {}`) instead.", "If dynamic code generation is truly necessary, consider safer alternatives like passing functions as parameters or using a more constrained domain-specific approach."]
-	} },
-	setup(context) {
-		function checkNode(node, { program, sourceFile, typeChecker }) {
-			if (isFunctionConstructor(node, typeChecker, program)) context.report({
-				message: "noFunctionConstructor",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		}
-		function isFunctionConstructor(node, typeChecker, program) {
-			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (isGlobalDeclarationOfName(node.expression, "Function", typeChecker, program)) return true;
-			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && isGlobalDeclaration(node.expression, typeChecker, program)) {
-				if (node.expression.name.text !== "Function") return false;
-				const object = node.expression.expression;
-				if (object.kind === SyntaxKind.Identifier) return object.text === "globalThis" || object.text === "window";
-			}
-			return false;
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { functionNewCalls_default as default };

package/lib/rules/generatorFunctionYields.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports generator functions that do not yield values.";
-    readonly id: "generatorFunctionYields";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingYield", undefined>;
-export default _default;

package/lib/rules/generatorFunctionYields.js

@@ -1,48 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/generatorFunctionYields.ts
-var generatorFunctionYields_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports generator functions that do not yield values.",
-		id: "generatorFunctionYields",
-		presets: ["logical"]
-	},
-	messages: { missingYield: {
-		primary: "Generator functions must contain at least one yield expression to produce values.",
-		secondary: [
-			"Generator functions use the `function*` syntax to create iterators that can produce multiple values over time.",
-			"Without a yield expression, the generator will not produce any values and behaves like an empty iterator.",
-			"This is likely unintentional and indicates incomplete implementation or a misunderstanding of generator functions."
-		],
-		suggestions: ["Add a `yield` expression to produce values from the generator.", "If the function should not be a generator, remove the asterisk (`*`) from the function declaration."]
-	} },
-	setup(context) {
-		return { visitors: {
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-			MethodDeclaration: checkFunction
-		} };
-		function checkFunction(node, { sourceFile }) {
-			if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) return;
-			context.report({
-				message: "missingYield",
-				range: {
-					begin: node.asteriskToken.getStart(sourceFile),
-					end: node.asteriskToken.getEnd()
-				}
-			});
-		}
-	}
-});
-function blockContainsYield(block) {
-	function checkForYield(node) {
-		if (node.kind === SyntaxKind.YieldExpression) return true;
-		if (tsutils.isFunctionScopeBoundary(node)) return false;
-		return ts.forEachChild(node, checkForYield);
-	}
-	return ts.forEachChild(block, checkForYield);
-}
-//#endregion
-export { generatorFunctionYields_default as default };

package/lib/rules/getterReturns.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports getter functions that do not return values.";
-    readonly id: "getterReturns";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingReturn", undefined>;
-export default _default;