@pobammer-ts/eslint-cease-nonsense-rules 0.4.1 → 0.4.3

package/dist/rules/use-exhaustive-dependencies.js

@@ -1,9 +1,26 @@
-/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
-/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+import { TSESTree } from "@typescript-eslint/types";
+import * as S from "sury";
+const FUNCTION_DECLARATIONS = new Set([
+    TSESTree.AST_NODE_TYPES.FunctionExpression,
+    TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+    TSESTree.AST_NODE_TYPES.FunctionDeclaration,
+]);
+const UNSTABLE_VALUES = new Set([
+    ...FUNCTION_DECLARATIONS,
+    TSESTree.AST_NODE_TYPES.ObjectExpression,
+    TSESTree.AST_NODE_TYPES.ArrayExpression,
+]);
+/**
+ * Internal metrics used for testing to ensure specific branches execute.
+ */
+const testingMetrics = {
+    moduleLevelStableConst: 0,
+    outerScopeSkip: 0,
+};
+function resetTestingMetrics() {
+    testingMetrics.moduleLevelStableConst = 0;
+    testingMetrics.outerScopeSkip = 0;
+}
 /**
  * Default hooks to check for exhaustive dependencies.
  */
@@ -14,6 +31,12 @@ const DEFAULT_HOOKS = new Map([
     ["useCallback", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useMemo", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useImperativeHandle", { closureIndex: 1, dependenciesIndex: 2 }],
+    // React Spring hooks (function factory pattern)
+    // Note: These hooks support both function and object patterns.
+    // Only the function pattern is analyzed for dependencies.
+    ["useSpring", { closureIndex: 0, dependenciesIndex: 1 }],
+    ["useSprings", { closureIndex: 1, dependenciesIndex: 2 }],
+    ["useTrail", { closureIndex: 1, dependenciesIndex: 2 }],
 ]);
 /**
  * Hooks with stable results that don't need to be in dependencies.
@@ -127,7 +150,7 @@ function getMemberExpressionDepth(node) {
     let depth = 0;
     let current = node;
     while (current.type === "MemberExpression") {
-        depth++;
+        depth += 1;
         current = current.object;
     }
     return depth;
@@ -140,9 +163,8 @@ function getMemberExpressionDepth(node) {
  */
 function getRootIdentifier(node) {
     let current = node;
-    while (current.type === "MemberExpression") {
+    while (current.type === "MemberExpression")
         current = current.object;
-    }
     return current.type === "Identifier" ? current : undefined;
 }
 /**
@@ -166,15 +188,13 @@ function nodeToDependencyString(node, sourceCode) {
 function isStableArrayIndex(stableResult, node, identifierName) {
     if (!stableResult)
         return false;
-    if (!(stableResult instanceof Set) || node.type !== "VariableDeclarator" || node.id.type !== "ArrayPattern") {
+    if (!(stableResult instanceof Set) || node.type !== "VariableDeclarator" || node.id.type !== "ArrayPattern")
         return false;
-    }
     const elements = node.id.elements;
-    for (let i = 0; i < elements.length; i++) {
-        const element = elements[i];
-        if (element && element.type === "Identifier" && element.name === identifierName) {
-            return stableResult.has(i);
-        }
+    for (let index = 0; index < elements.length; index += 1) {
+        const element = elements[index];
+        if (element?.type === "Identifier" && element.name === identifierName)
+            return stableResult.has(index);
     }
     return false;
 }
@@ -222,15 +242,13 @@ function isStableValue(variable, identifierName, stableHooks) {
         // Check for const declarations with constant initializers
         if (type === "Variable" && node.type === "VariableDeclarator") {
             const parent = node.parent;
-            if (!parent || parent.type !== "VariableDeclaration" || parent.kind !== "const") {
+            if (!parent || parent.type !== "VariableDeclaration" || parent.kind !== "const")
                 continue;
-            }
             const { init } = node;
             // Check if it's from a stable hook first
             // @ts-expect-error - Type mismatch between ESLint and TypeScript AST types
-            if (init && isStableHookValue(init, node, identifierName, stableHooks)) {
+            if (init && isStableHookValue(init, node, identifierName, stableHooks))
                 return true;
-            }
             // Check for React Lua bindings - bindings are always stable
             if (init?.type === "CallExpression") {
                 const { callee } = init;
@@ -239,25 +257,21 @@ function isStableValue(variable, identifierName, stableHooks) {
                     callee.object.type === "Identifier" &&
                     callee.object.name === "React" &&
                     callee.property.type === "Identifier" &&
-                    callee.property.name === "joinBindings") {
+                    callee.property.name === "joinBindings")
                     return true;
-                }
                 // .map() on bindings returns a stable binding
                 // This covers: binding.map(...), React.joinBindings(...).map(...), etc.
                 if (callee.type === "MemberExpression" &&
                     callee.property.type === "Identifier" &&
-                    callee.property.name === "map") {
+                    callee.property.name === "map")
                     return true;
-                }
             }
             // Check for literal values FIRST (stable regardless of scope)
             if (init) {
-                if (init.type === "Literal" || init.type === "TemplateLiteral") {
+                if (init.type === "Literal" || init.type === "TemplateLiteral")
                     return true;
-                }
-                if (init.type === "UnaryExpression" && init.argument.type === "Literal") {
+                if (init.type === "UnaryExpression" && init.argument.type === "Literal")
                     return true;
-                }
             }
             // For non-literal constants, only module-level is stable
             // Component-scoped non-literal constants are recreated on every render
@@ -266,6 +280,7 @@ function isStableValue(variable, identifierName, stableHooks) {
                 const declParent = varDef.node.parent?.parent;
                 // Module-level (Program or ExportNamedDeclaration)
                 if (declParent && (declParent.type === "Program" || declParent.type === "ExportNamedDeclaration")) {
+                    testingMetrics.moduleLevelStableConst += 1;
                     return true;
                 }
             }
@@ -289,6 +304,12 @@ function findTopmostMemberExpression(node) {
     }
     return current;
 }
+const IS_CEASE_BOUNDARY = new Set([
+    TSESTree.AST_NODE_TYPES.FunctionDeclaration,
+    TSESTree.AST_NODE_TYPES.FunctionExpression,
+    TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+    TSESTree.AST_NODE_TYPES.VariableDeclarator,
+]);
 /**
  * Checks if an identifier is in a TypeScript type-only position.
  * Type parameters and type annotations are compile-time only and should not be dependencies.
@@ -300,16 +321,11 @@ function isInTypePosition(identifier) {
     let parent = identifier.parent;
     while (parent) {
         // Any TypeScript-specific node indicates a type-only position
-        if (parent.type.startsWith("TS")) {
+        if (parent.type.startsWith("TS"))
             return true;
-        }
         // Stop searching at certain boundaries
-        if (parent.type === "FunctionDeclaration" ||
-            parent.type === "FunctionExpression" ||
-            parent.type === "ArrowFunctionExpression" ||
-            parent.type === "VariableDeclarator") {
+        if (IS_CEASE_BOUNDARY.has(parent.type))
             return false;
-        }
         parent = parent.parent;
     }
     return false;
@@ -328,9 +344,7 @@ function isDeclaredInComponentBody(variable, closureNode) {
     // Find the parent component/hook function
     let parent = closureNode.parent;
     while (parent) {
-        const isFunction = parent.type === "FunctionDeclaration" ||
-            parent.type === "FunctionExpression" ||
-            parent.type === "ArrowFunctionExpression";
+        const isFunction = FUNCTION_DECLARATIONS.has(parent.type);
         if (isFunction) {
             // Capture parent in a const so TypeScript understands it's stable in closures
             const functionParent = parent;
@@ -342,15 +356,13 @@ function isDeclaredInComponentBody(variable, closureNode) {
                 // Just check if the definition's node is the current function parent
                 return def.node === functionParent;
             });
-            if (isParameter) {
+            if (isParameter)
                 return true; // Props are reactive
-            }
             // Check if variable is defined inside this function
             return variable.defs.some((def) => {
                 let node = def.node.parent;
-                while (node && node !== functionParent) {
+                while (node && node !== functionParent)
                     node = node.parent;
-                }
                 return node === functionParent;
             });
         }
@@ -358,6 +370,39 @@ function isDeclaredInComponentBody(variable, closureNode) {
     }
     return false;
 }
+/**
+ * Resolves an identifier to its function definition if it references a function.
+ *
+ * @param identifier - The identifier node.
+ * @param scope - The scope to search in.
+ * @returns The function node if found, undefined otherwise.
+ */
+function resolveFunctionReference(identifier, scope) {
+    // Look up the variable in the scope chain
+    let variable;
+    let currentScope = scope;
+    while (currentScope) {
+        variable = currentScope.set.get(identifier.name);
+        if (variable)
+            break;
+        currentScope = currentScope.upper;
+    }
+    if (!variable || variable.defs.length === 0)
+        return undefined;
+    // Check all definitions for a function
+    for (const def of variable.defs) {
+        const { node } = def;
+        // Direct function declaration
+        if (node.type === "FunctionDeclaration")
+            return node;
+        // Variable declarator with function initializer
+        if (node.type === "VariableDeclarator" &&
+            node.init &&
+            (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression"))
+            return node.init;
+    }
+    return undefined;
+}
 /**
  * Collects all captured identifiers from a closure.
  *
@@ -367,7 +412,7 @@ function isDeclaredInComponentBody(variable, closureNode) {
  * @returns Array of captured identifiers.
  */
 function collectCaptures(node, scope, sourceCode) {
-    const captures = [];
+    const captures = new Array();
     const captureSet = new Set();
     /**
      * Recursively visits nodes to find identifier references.
@@ -411,6 +456,7 @@ function collectCaptures(node, scope, sourceCode) {
                     // Per React rules, only "variables declared directly inside the component body" are reactive
                     // Variables from outer scopes (module-level, parent functions) are non-reactive and stable
                     if (!isDeclaredInComponentBody(variable, node)) {
+                        testingMetrics.outerScopeSkip += 1;
                         return; // From outer scope - skip
                     }
                     captureSet.add(name);
@@ -421,17 +467,24 @@ function collectCaptures(node, scope, sourceCode) {
                         name,
                         node: depthNode,
                         usagePath,
-                        variable,
+                        variable: variable,
                     });
                 }
             }
         }
+        // Unwrap TypeScript type expressions to visit the actual expression
+        if (current.type === "TSSatisfiesExpression" ||
+            current.type === "TSAsExpression" ||
+            current.type === "TSTypeAssertion" ||
+            current.type === "TSNonNullExpression") {
+            visit(current.expression);
+            return;
+        }
         // Traverse member expressions
         if (current.type === "MemberExpression") {
             visit(current.object);
-            if (current.computed) {
+            if (current.computed)
                 visit(current.property);
-            }
             return;
         }
         // Visit children
@@ -439,15 +492,12 @@ function collectCaptures(node, scope, sourceCode) {
         for (const key of keys) {
             const value = current[key];
             if (Array.isArray(value)) {
-                for (const item of value) {
-                    if (item && typeof item === "object" && "type" in item) {
+                for (const item of value)
+                    if (item && typeof item === "object" && "type" in item)
                         visit(item);
-                    }
-                }
             }
-            else if (value && typeof value === "object" && "type" in value) {
+            else if (value && typeof value === "object" && "type" in value)
                 visit(value);
-            }
         }
     }
     visit(node);
@@ -461,7 +511,7 @@ function collectCaptures(node, scope, sourceCode) {
  * @returns Array of dependency information.
  */
 function parseDependencies(node, sourceCode) {
-    const dependencies = [];
+    const dependencies = new Array();
     for (const element of node.elements) {
         if (!element || element.type === "SpreadElement")
             continue;
@@ -482,23 +532,12 @@ function parseDependencies(node, sourceCode) {
  * @returns True if the node is an unstable value.
  */
 function isUnstableValue(node) {
-    if (!node)
-        return false;
-    // Inline functions
-    if (node.type === "FunctionExpression" ||
-        node.type === "ArrowFunctionExpression" ||
-        node.type === "FunctionDeclaration") {
-        return true;
-    }
-    // Object literals
-    if (node.type === "ObjectExpression") {
-        return true;
-    }
-    // Array literals
-    if (node.type === "ArrayExpression") {
-        return true;
-    }
-    return false;
+    return node ? UNSTABLE_VALUES.has(node.type) : false;
+}
+const isNumberArray = S.array(S.number);
+const isStringArray = S.array(S.string);
+function validate(validator, value) {
+    return S.safe(() => S.parseOrThrow(value, validator)).success;
 }
 /**
  * Converts stableResult configuration to internal format.
@@ -511,12 +550,10 @@ function convertStableResult(stableResult) {
         return stableResult;
     if (typeof stableResult === "number")
         return new Set([stableResult]);
-    if (Array.isArray(stableResult) && stableResult.length > 0) {
-        if (typeof stableResult[0] === "number") {
-            return new Set(stableResult);
-        }
+    if (validate(isNumberArray, stableResult) && stableResult.length > 0)
+        return new Set(stableResult);
+    if (validate(isStringArray, stableResult) && stableResult.length > 0)
         return new Set(stableResult);
-    }
     return false;
 }
 const useExhaustiveDependencies = {
@@ -577,56 +614,90 @@ const useExhaustiveDependencies = {
                 const closureArg = args[closureIndex];
                 if (!closureArg)
                     return;
-                // Early exit: check if closure is a function
-                if (closureArg.type !== "ArrowFunctionExpression" && closureArg.type !== "FunctionExpression") {
-                    return;
+                // Resolve the actual closure function (handles both inline and reference cases)
+                let closureFunction;
+                if (closureArg.type === "ArrowFunctionExpression" || closureArg.type === "FunctionExpression") {
+                    closureFunction = closureArg;
                 }
+                else if (closureArg.type === "Identifier") {
+                    // Function reference - try to resolve it
+                    const scope = getScope(callNode);
+                    closureFunction = resolveFunctionReference(closureArg, scope);
+                }
+                // Early exit: check if we have a valid closure function
+                if (!closureFunction)
+                    return;
                 // Get dependencies argument
-                const depsArg = args[dependenciesIndex];
+                const dependenciesArgument = args[dependenciesIndex];
                 // Report missing dependencies array if configured
-                if (!depsArg && options.reportMissingDependenciesArray) {
+                if (!dependenciesArgument && options.reportMissingDependenciesArray) {
                     // Collect captures to see if any are needed
-                    const scope = getScope(closureArg);
-                    const captures = collectCaptures(closureArg, scope, context.sourceCode);
+                    const scope = getScope(closureFunction);
+                    const captures = collectCaptures(closureFunction, scope, context.sourceCode);
                     // Filter out stable values
                     const requiredCaptures = captures.filter((capture) => !isStableValue(capture.variable, capture.name, stableHooks));
                     if (requiredCaptures.length > 0) {
-                        const missingNames = Array.from(new Set(requiredCaptures.map((c) => c.name))).join(", ");
+                        const missingNames = Array.from(new Set(requiredCaptures.map(({ name }) => name))).join(", ");
+                        // Generate fix suggestion - add dependencies array
+                        const usagePaths = requiredCaptures.map(({ usagePath }) => usagePath);
+                        const uniqueDeps = Array.from(new Set(usagePaths)).toSorted();
+                        const depsArrayString = `[${uniqueDeps.join(", ")}]`;
                         context.report({
                             data: { deps: missingNames },
                             messageId: "missingDependenciesArray",
                             node: callNode,
+                            suggest: [
+                                {
+                                    desc: `Add dependencies array: ${depsArrayString}`,
+                                    fix(fixer) {
+                                        // Insert the dependencies array after the closure argument
+                                        const closureArgNode = args[closureIndex];
+                                        return fixer.insertTextAfter(closureArgNode, `, ${depsArrayString}`);
+                                    },
+                                },
+                            ],
                         });
                     }
                     return;
                 }
                 // Early exit: no dependencies array
-                if (!depsArg)
+                if (!dependenciesArgument)
                     return;
                 // Dependencies must be an array
-                if (depsArg.type !== "ArrayExpression")
+                if (dependenciesArgument.type !== "ArrayExpression")
                     return;
-                const depsArray = depsArg;
+                const depsArray = dependenciesArgument;
                 // Collect captures from closure
-                const scope = getScope(closureArg);
-                const captures = collectCaptures(closureArg, scope, context.sourceCode);
+                const scope = getScope(closureFunction);
+                const captures = collectCaptures(closureFunction, scope, context.sourceCode);
                 // Parse dependencies array
                 const dependencies = parseDependencies(depsArray, context.sourceCode);
                 // Check for unnecessary dependencies first (for consistent error ordering)
-                for (const dep of dependencies) {
-                    const depRootIdent = getRootIdentifier(dep.node);
-                    if (!depRootIdent)
+                for (const dependency of dependencies) {
+                    const dependencyRootIdentifier = getRootIdentifier(dependency.node);
+                    if (!dependencyRootIdentifier)
                         continue;
-                    const depName = depRootIdent.name;
+                    const dependencyName = dependencyRootIdentifier.name;
                     // Find all captures with the same root identifier
-                    const matchingCaptures = captures.filter((c) => getRootIdentifier(c.node)?.name === depName);
+                    const matchingCaptures = captures.filter(({ node }) => getRootIdentifier(node)?.name === dependencyName);
                     // If no captures use this identifier at all, it's unnecessary
                     if (matchingCaptures.length === 0) {
                         if (options.reportUnnecessaryDependencies) {
+                            // Generate fix suggestion
+                            const newDeps = dependencies.filter((d) => d.name !== dependency.name).map((d) => d.name);
+                            const newDepsString = `[${newDeps.join(", ")}]`;
                             context.report({
-                                data: { name: dep.name },
+                                data: { name: dependency.name },
                                 messageId: "unnecessaryDependency",
-                                node: dep.node,
+                                node: dependency.node,
+                                suggest: [
+                                    {
+                                        desc: `Remove '${dependency.name}' from dependencies array`,
+                                        fix(fixer) {
+                                            return fixer.replaceText(depsArray, newDepsString);
+                                        },
+                                    },
+                                ],
                             });
                         }
                         continue;
@@ -634,11 +705,22 @@ const useExhaustiveDependencies = {
                     // Check if dependency is more specific than any usage
                     // dep.depth > all capture depths means the dep is too specific
                     const maxCaptureDepth = Math.max(...matchingCaptures.map((c) => c.depth));
-                    if (dep.depth > maxCaptureDepth && options.reportUnnecessaryDependencies) {
+                    if (dependency.depth > maxCaptureDepth && options.reportUnnecessaryDependencies) {
+                        // Generate fix suggestion
+                        const newDeps = dependencies.filter((d) => d.name !== dependency.name).map((d) => d.name);
+                        const newDepsString = `[${newDeps.join(", ")}]`;
                         context.report({
-                            data: { name: dep.name },
+                            data: { name: dependency.name },
                             messageId: "unnecessaryDependency",
-                            node: dep.node,
+                            node: dependency.node,
+                            suggest: [
+                                {
+                                    desc: `Remove '${dependency.name}' from dependencies array`,
+                                    fix(fixer) {
+                                        return fixer.replaceText(depsArray, newDepsString);
+                                    },
+                                },
+                            ],
                         });
                     }
                 }
@@ -648,27 +730,39 @@ const useExhaustiveDependencies = {
                     if (isStableValue(capture.variable, capture.name, stableHooks))
                         continue;
                     // Check if the capture is in the dependencies
-                    const rootIdent = getRootIdentifier(capture.node);
-                    if (!rootIdent)
+                    const rootIdentifier = getRootIdentifier(capture.node);
+                    if (!rootIdentifier)
                         continue;
-                    const captureName = rootIdent.name;
-                    let isInDeps = false;
+                    const captureName = rootIdentifier.name;
+                    let isInDependencies = false;
                     // Check if capture is covered by dependencies
-                    for (const dep of dependencies) {
-                        const depRootIdent = getRootIdentifier(dep.node);
+                    for (const dependency of dependencies) {
+                        const dependencyRootIdentifier = getRootIdentifier(dependency.node);
                         // Check name match and depth: dependency should not be more specific than capture
-                        if (depRootIdent?.name === captureName && dep.depth <= capture.depth) {
-                            isInDeps = true;
+                        if (dependencyRootIdentifier?.name === captureName && dependency.depth <= capture.depth) {
+                            isInDependencies = true;
                             break;
                         }
                     }
-                    if (!isInDeps) {
+                    if (!isInDependencies) {
                         // Report on the last dependency in the array for better error positioning
-                        const lastDep = dependencies[dependencies.length - 1];
+                        const lastDependency = dependencies.at(-1);
+                        // Generate fix suggestion
+                        const dependencyNames = dependencies.map(({ name }) => name);
+                        const newDependencies = [...dependencyNames, capture.usagePath].toSorted();
+                        const newDependenciesString = `[${newDependencies.join(", ")}]`;
                         context.report({
                             data: { name: capture.usagePath },
                             messageId: "missingDependency",
-                            node: lastDep?.node || depsArray,
+                            node: lastDependency?.node || depsArray,
+                            suggest: [
+                                {
+                                    desc: `Add '${capture.usagePath}' to dependencies array`,
+                                    fix(fixer) {
+                                        return fixer.replaceText(depsArray, newDependenciesString);
+                                    },
+                                },
+                            ],
                         });
                     }
                 }
@@ -678,23 +772,25 @@ const useExhaustiveDependencies = {
                     if (isStableValue(capture.variable, capture.name, stableHooks))
                         continue;
                     // Check if this capture has a corresponding dependency
-                    const rootIdent = getRootIdentifier(capture.node);
-                    if (!rootIdent)
+                    const rootIdentifier = getRootIdentifier(capture.node);
+                    if (!rootIdentifier)
                         continue;
-                    const captureName = rootIdent.name;
+                    const captureName = rootIdentifier.name;
                     // Find if there's a matching dependency
-                    for (const dep of dependencies) {
-                        const depRootIdent = getRootIdentifier(dep.node);
-                        const isMatch = depRootIdent?.name === captureName && dep.depth === capture.depth;
-                        const isDirectIdentifier = dep.depth === 0;
+                    for (const dependency of dependencies) {
+                        const dependencyRootIdentifier = getRootIdentifier(dependency.node);
+                        const isMatch = dependencyRootIdentifier?.name === captureName && dependency.depth === capture.depth;
+                        const isDirectIdentifier = dependency.depth === 0;
                         if (isMatch && isDirectIdentifier) {
-                            const def = capture.variable?.defs[0];
-                            const initNode = def?.node.type === "VariableDeclarator" ? def.node.init : undefined;
-                            if (isUnstableValue(initNode)) {
+                            const variableDefinition = capture.variable?.defs[0];
+                            const initialNode = variableDefinition?.node.type === "VariableDeclarator"
+                                ? (variableDefinition.node.init ?? undefined)
+                                : undefined;
+                            if (isUnstableValue(initialNode)) {
                                 context.report({
                                     data: { name: capture.usagePath },
                                     messageId: "unstableDependency",
-                                    node: dep.node,
+                                    node: dependency.node,
                                 });
                             }
                             break;
@@ -713,6 +809,7 @@ const useExhaustiveDependencies = {
             url: "https://biomejs.dev/linter/rules/use-exhaustive-dependencies/",
         },
         fixable: "code",
+        hasSuggestions: true,
         messages: {
             missingDependenciesArray: "This hook does not specify its dependencies array. Missing: {{deps}}",
             missingDependency: "This hook does not specify its dependency on {{name}}.",
@@ -772,5 +869,15 @@ const useExhaustiveDependencies = {
         type: "problem",
     },
 };
+export const __testing = {
+    collectCaptures,
+    convertStableResult,
+    isDeclaredInComponentBody,
+    isInTypePosition,
+    isStableArrayIndex,
+    isStableValue,
+    metrics: testingMetrics,
+    resetMetrics: resetTestingMetrics,
+};
 export default useExhaustiveDependencies;
 //# sourceMappingURL=use-exhaustive-dependencies.js.map