@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/forInGuards.d.ts

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

package/lib/rules/forInGuards.js

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

package/lib/rules/functionApplySpreads.d.ts

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

package/lib/rules/functionApplySpreads.js

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

package/lib/rules/functionAssignments.d.ts

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

package/lib/rules/functionAssignments.js

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

package/lib/rules/functionCurryingRedundancy.d.ts

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

package/lib/rules/functionCurryingRedundancy.js

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

package/lib/rules/functionDeclarationStyles.d.ts

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

package/lib/rules/functionDeclarationStyles.js

@@ -1,67 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z } 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.boolean().default(false).describe("Whether to allow arrow functions when style is 'declaration'."),
-		style: z.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 };
-
-//# sourceMappingURL=functionDeclarationStyles.js.map

package/lib/rules/functionNameMatches.d.ts

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

package/lib/rules/functionNameMatches.js

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

package/lib/rules/functionNewCalls.d.ts

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

package/lib/rules/functionNewCalls.js

@@ -1,42 +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, { sourceFile, typeChecker }) {
-			if (isFunctionConstructor(node, typeChecker)) context.report({
-				message: "noFunctionConstructor",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		}
-		function isFunctionConstructor(node, typeChecker) {
-			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (isGlobalDeclarationOfName(node.expression, "Function", typeChecker)) return true;
-			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && isGlobalDeclaration(node.expression, typeChecker)) {
-				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 };
-
-//# sourceMappingURL=functionNewCalls.js.map

package/lib/rules/generatorFunctionYields.d.ts

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

package/lib/rules/generatorFunctionYields.js

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

package/lib/rules/getterReturns.d.ts

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

package/lib/rules/getterReturns.js

@@ -1,65 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/getterReturns.ts
-var getterReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports getter functions that do not return values.",
-		id: "getterReturns",
-		presets: ["javascript"]
-	},
-	messages: { missingReturn: {
-		primary: "This getter implicitly returns `undefined` because it does not explicitly `return` a value.",
-		secondary: ["A `get` accessor is expected to return a value when the property is accessed.", "A getter without a return statement will implicitly return `undefined`, which is likely unintentional."],
-		suggestions: ["Add a return statement with the desired value.", "If the property should not have a value, consider using a regular method instead."]
-	} },
-	setup(context) {
-		return { visitors: { GetAccessor: (node, { sourceFile }) => {
-			if (node.body && !statementsReturnValue(node.body.statements)) context.report({
-				message: "missingReturn",
-				range: {
-					begin: node.name.getStart(sourceFile),
-					end: node.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-function ifStatementReturnsValue(statement) {
-	return !!(statement.elseStatement && statementReturnsValue(statement.thenStatement) && statementReturnsValue(statement.elseStatement));
-}
-function statementReturnsValue(statement) {
-	switch (statement.kind) {
-		case SyntaxKind.Block: return statementsReturnValue(statement.statements);
-		case SyntaxKind.IfStatement: return ifStatementReturnsValue(statement);
-		case SyntaxKind.ReturnStatement: return statement.expression !== void 0;
-		case SyntaxKind.SwitchStatement: return switchStatementReturnsValue(statement);
-		case SyntaxKind.ThrowStatement: return true;
-		case SyntaxKind.TryStatement: return tryStatementReturnsValue(statement);
-		default: return false;
-	}
-}
-function statementsReturnValue(statements) {
-	return statements.some(statementReturnsValue);
-}
-function switchStatementReturnsValue(statement) {
-	const clauses = statement.caseBlock.clauses;
-	if (!clauses.length) return false;
-	let hasDefault = false;
-	for (const clause of clauses) {
-		if (clause.kind === SyntaxKind.DefaultClause) hasDefault = true;
-		if (!statementsReturnValue(clause.statements)) return false;
-	}
-	return hasDefault;
-}
-function tryStatementReturnsValue(statement) {
-	if (statement.finallyBlock && statementsReturnValue(statement.finallyBlock.statements)) return true;
-	const tryReturns = statementsReturnValue(statement.tryBlock.statements);
-	if (!statement.catchClause) return tryReturns;
-	const catchReturns = statementsReturnValue(statement.catchClause.block.statements);
-	return tryReturns && catchReturns;
-}
-//#endregion
-export { getterReturns_default as default };
-
-//# sourceMappingURL=getterReturns.js.map

package/lib/rules/globalAssignments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
-    readonly id: "globalAssignments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noGlobalAssign", undefined>;
-export default _default;
-//# sourceMappingURL=globalAssignments.d.ts.map