@flint.fyi/ts 0.14.6 → 0.18.0

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,6 +1,10 @@
 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, import("../language.js").TypeScriptServices, "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,60 +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) {
-            if (isFunctionConstructor(node)) {
-                context.report({
-                    message: "noFunctionConstructor",
-                    range: getTSNodeRange(node.expression, context.sourceFile),
-                });
-            }
-        }
-        function isFunctionConstructor(node) {
-            if (ts.isIdentifier(node.expression)) {
-                if (isGlobalDeclarationOfName(node.expression, "Function", context.typeChecker)) {
-                    return true;
-                }
-            }
-            else if (ts.isPropertyAccessExpression(node.expression) &&
-                isGlobalDeclaration(node.expression, context.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,6 +1,10 @@
 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, import("../language.js").TypeScriptServices, "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,57 +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) {
-            if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) {
-                return;
-            }
-            context.report({
-                message: "missingYield",
-                range: {
-                    begin: node.asteriskToken.getStart(context.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,6 +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").TypeScriptServices, "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

package/lib/rules/globalAssignments.js

@@ -1,59 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalVariable } from "../utils/isGlobalVariable.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
-        id: "globalAssignments",
-        preset: "untyped",
-    },
-    messages: {
-        noGlobalAssign: {
-            primary: "Read-only global variables should not be reassigned or modified.",
-            secondary: [
-                "Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
-                "Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
-                "In strict mode, reassigning these globals will throw a TypeError at runtime.",
-            ],
-            suggestions: [
-                "Use a different variable name instead of shadowing or reassigning globals.",
-                "If you need a similar name, consider using a more specific name that doesn't conflict with global variables.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                BinaryExpression: (node) => {
-                    if (tsutils.isAssignmentKind(node.operatorToken.kind) &&
-                        isGlobalVariable(node.left, context.typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.left, context.sourceFile),
-                        });
-                    }
-                },
-                PostfixUnaryExpression: (node) => {
-                    if (isGlobalVariable(node.operand, context.typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, context.sourceFile),
-                        });
-                    }
-                },
-                PrefixUnaryExpression: (node) => {
-                    if ((node.operator === ts.SyntaxKind.PlusPlusToken ||
-                        node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                        isGlobalVariable(node.operand, context.typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, context.sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+//#region src/rules/globalAssignments.ts
+var globalAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
+		id: "globalAssignments",
+		presets: ["javascript"]
+	},
+	messages: { noGlobalAssign: {
+		primary: "Read-only global variables should not be reassigned or modified.",
+		secondary: [
+			"Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
+			"Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
+			"In strict mode, reassigning these globals will throw a TypeError at runtime."
+		],
+		suggestions: ["Use a different variable name instead of shadowing or reassigning globals.", "If you need a similar name, consider using a more specific name that doesn't conflict with global variables."]
+	} },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression: (node, { sourceFile, typeChecker }) => {
+				if (tsutils.isAssignmentKind(node.operatorToken.kind) && isGlobalVariable(node.left, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.left, sourceFile)
+				});
+			},
+			PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
+				if (isGlobalVariable(node.operand, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.operand, sourceFile)
+				});
+			},
+			PrefixUnaryExpression: (node, { sourceFile, typeChecker }) => {
+				if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) && isGlobalVariable(node.operand, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.operand, sourceFile)
+				});
+			}
+		} };
+	}
 });
+//#endregion
+export { globalAssignments_default as default };
+
+//# sourceMappingURL=globalAssignments.js.map

package/lib/rules/globalObjectCalls.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
     readonly id: "globalObjectCalls";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noGlobalObjectCall", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noGlobalObjectCall", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=globalObjectCalls.d.ts.map