@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/functionCurryingRedundancy.js

@@ -1,77 +1,53 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { isFunction } from "../utils/isFunction.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.",
-        id: "functionCurryingRedundancy",
-        preset: "logical",
-    },
-    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 (!ts.isPropertyAccessExpression(node.expression)) {
-                        return;
-                    }
-                    const method = node.expression.name.text;
-                    if ((method !== "call" && method !== "apply") ||
-                        !node.arguments.length ||
-                        !isFunction(node.expression.expression, typeChecker)) {
-                        return;
-                    }
-                    const firstArgument = node.arguments[0];
-                    if (firstArgument.kind !== ts.SyntaxKind.NullKeyword &&
-                        !(ts.isIdentifier(firstArgument) &&
-                            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(),
-                        },
-                    });
-                },
-            },
-        };
-    },
+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 > 0) {
-        const argsArray = methodArguments[0];
-        return `${functionExpression}(...${argsArray.getText(sourceFile)})`;
-    }
-    else {
-        return `${functionExpression}()`;
-    }
+	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) {
-    const argsText = methodArguments
-        .map((arg) => arg.getText(sourceFile))
-        .join(", ");
-    return `${functionExpression}(${argsText})`;
+	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

@@ -0,0 +1,16 @@
+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";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferDeclaration" | "preferExpression", {
+    readonly allowArrowFunctions: z.ZodDefault<z.ZodBoolean>;
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        expression: "expression";
+        declaration: "declaration";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=functionDeclarationStyles.d.ts.map

package/lib/rules/functionDeclarationStyles.js

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "mismatch", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=functionNameMatches.d.ts.map

package/lib/rules/functionNameMatches.js

@@ -0,0 +1,74 @@
+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,8 +1,10 @@
-import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the Function constructor to create functions from strings.";
     readonly id: "functionNewCalls";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "noFunctionConstructor", undefined>;
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noFunctionConstructor", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=functionNewCalls.d.ts.map

package/lib/rules/functionNewCalls.js

@@ -1,61 +1,42 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using the Function constructor to create functions from strings.",
-        id: "functionNewCalls",
-        preset: "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 (ts.isIdentifier(node.expression)) {
-                if (isGlobalDeclarationOfName(node.expression, "Function", typeChecker)) {
-                    return true;
-                }
-            }
-            else if (ts.isPropertyAccessExpression(node.expression) &&
-                isGlobalDeclaration(node.expression, typeChecker)) {
-                const propertyName = node.expression.name.text;
-                if (propertyName !== "Function") {
-                    return false;
-                }
-                const object = node.expression.expression;
-                if (ts.isIdentifier(object)) {
-                    return object.text === "globalThis" || object.text === "window";
-                }
-            }
-            return false;
-        }
-        return {
-            visitors: {
-                CallExpression: checkNode,
-                NewExpression: checkNode,
-            },
-        };
-    },
+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,8 +1,10 @@
-import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports generator functions that do not yield values.";
     readonly id: "generatorFunctionYields";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "missingYield", undefined>;
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingYield", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=generatorFunctionYields.d.ts.map

package/lib/rules/generatorFunctionYields.js

@@ -1,58 +1,50 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports generator functions that do not yield values.",
-        id: "generatorFunctionYields",
-        preset: "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(),
-                },
-            });
-        }
-    },
+//#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 (ts.isYieldExpression(node)) {
-            return true;
-        }
-        if (tsutils.isFunctionScopeBoundary(node)) {
-            return false;
-        }
-        return ts.forEachChild(node, checkForYield);
-    }
-    return ts.forEachChild(block, checkForYield);
+	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

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports getter functions that do not return values.";
+    readonly id: "getterReturns";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingReturn", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=getterReturns.d.ts.map

package/lib/rules/getterReturns.js

@@ -0,0 +1,65 @@
+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,7 +1,10 @@
 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 preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noGlobalAssign", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noGlobalAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=globalAssignments.d.ts.map