eslint-plugin-code-style 1.3.10 → 1.4.3

package/index.js

@@ -1794,32 +1794,78 @@ const functionNamingConvention = {
 
         const hookRegex = /^use[A-Z]/;
 
+        // Comprehensive list of English verbs commonly used in function names
+        // Organized by category for maintainability
         const verbPrefixes = [
+            // CRUD & Data operations
             "get", "set", "fetch", "load", "save", "create", "update", "delete", "remove", "add",
-            "is", "has", "can", "should", "will", "did", "was", "were",
-            "check", "validate", "verify", "confirm", "ensure",
+            "insert", "append", "prepend", "push", "pop", "shift", "unshift", "put", "patch",
+            // Boolean checks
+            "is", "has", "can", "should", "will", "did", "was", "were", "does", "do",
+            // Validation
+            "check", "validate", "verify", "confirm", "ensure", "assert", "test", "match",
+            // Search & Filter
             "find", "search", "filter", "sort", "map", "reduce", "merge", "split", "join",
+            "query", "lookup", "locate", "detect", "identify", "discover", "scan", "probe",
+            // Transformation
             "parse", "format", "convert", "transform", "normalize", "serialize", "deserialize",
-            "encode", "decode", "encrypt", "decrypt", "hash", "sign",
-            "render", "display", "show", "hide", "toggle", "enable", "disable",
-            "open", "close", "start", "stop", "init", "setup", "reset", "clear",
-            "connect", "disconnect", "subscribe", "unsubscribe", "listen", "emit",
+            "encode", "decode", "encrypt", "decrypt", "hash", "sign", "compress", "decompress",
+            "stringify", "objectify", "flatten", "unflatten", "transpose", "invert",
+            // String manipulation
+            "strip", "trim", "pad", "wrap", "unwrap", "sanitize", "escape", "unescape",
+            "capitalize", "lowercase", "uppercase", "camel", "snake", "kebab", "truncate",
+            "replace", "substitute", "interpolate", "template", "render",
+            // Display & UI
+            "display", "show", "hide", "toggle", "enable", "disable", "activate", "deactivate",
+            "highlight", "focus", "blur", "select", "deselect", "expand", "collapse", "resize",
+            "animate", "transition", "fade", "slide", "zoom", "rotate", "scale",
+            // Lifecycle
+            "open", "close", "start", "stop", "init", "setup", "reset", "clear", "destroy",
+            "mount", "unmount", "attach", "detach", "bind", "unbind", "dispose", "cleanup",
+            "register", "unregister", "install", "uninstall", "configure", "reconfigure",
+            // Network & Communication
+            "connect", "disconnect", "subscribe", "unsubscribe", "listen", "emit", "broadcast",
             "send", "receive", "request", "respond", "submit", "cancel", "abort", "poll",
-            "read", "write", "copy", "move", "clone", "extract", "insert", "append", "prepend",
+            "download", "upload", "import", "export", "sync", "stream", "pipe",
+            // File & I/O
+            "read", "write", "copy", "move", "clone", "extract", "archive", "restore", "backup",
+            // Computation
             "build", "make", "generate", "compute", "calculate", "process", "execute", "run",
-            "apply", "call", "invoke", "trigger", "fire", "dispatch",
-            "mount", "unmount", "attach", "detach", "bind", "unbind",
-            "register", "unregister", "activate", "deactivate",
-            "login", "logout", "authenticate", "authorize",
-            "navigate", "redirect", "route", "scroll", "focus", "blur",
-            "select", "deselect", "expand", "collapse", "resize", "refresh", "reload",
-            "download", "upload", "import", "export", "sync", "async",
-            "log", "warn", "error", "debug", "trace", "print",
-            "wrap", "unwrap", "sanitize", "escape", "unescape", "trim", "pad",
-            "count", "sum", "avg", "min", "max", "clamp", "round", "floor", "ceil",
-            "throw", "catch", "resolve", "reject", "retry", "await",
+            "evaluate", "analyze", "measure", "benchmark", "profile", "optimize",
+            "count", "sum", "avg", "min", "max", "clamp", "round", "floor", "ceil", "abs",
+            // Invocation
+            "apply", "call", "invoke", "trigger", "fire", "dispatch", "emit", "raise", "signal",
+            // Auth
+            "login", "logout", "authenticate", "authorize", "grant", "revoke", "permit", "deny",
+            // Navigation
+            "navigate", "redirect", "route", "scroll", "jump", "go", "back", "forward",
+            "refresh", "reload", "restore",
+            // Logging
+            "log", "warn", "error", "debug", "trace", "print", "dump", "inspect",
+            // Error handling
+            "throw", "catch", "resolve", "reject", "retry", "await", "recover", "fallback",
+            // Performance
             "debounce", "throttle", "memoize", "cache", "batch", "queue", "defer", "delay",
-            "handle", "on", "click", "change", "input", "submit", "press", "drag", "drop",
+            "schedule", "preload", "prefetch", "lazy",
+            // Events
+            "handle", "on", "click", "change", "input", "press", "drag", "drop",
+            "hover", "enter", "leave", "touch", "swipe", "pinch", "tap",
+            // Comparison
+            "compare", "diff", "equal", "differ", "overlap", "intersect", "union", "exclude",
+            // Grouping
+            "group", "ungroup", "partition", "chunk", "segment", "categorize", "classify",
+            // Ordering
+            "order", "reorder", "arrange", "reverse", "shuffle", "randomize", "pick", "sample",
+            // Validation state
+            "lock", "unlock", "freeze", "unfreeze", "seal", "mark", "unmark", "flag", "unflag",
+            // Misc common verbs
+            "use", "require", "need", "want", "try", "attempt", "ensure", "guarantee",
+            "prepare", "finalize", "complete", "finish", "end", "begin", "continue", "resume",
+            "pause", "suspend", "interrupt", "break", "skip", "ignore", "include", "exclude",
+            "accept", "decline", "approve", "reject", "confirm", "dismiss", "acknowledge",
+            "assign", "allocate", "distribute", "collect", "gather", "aggregate", "accumulate",
+            "populate", "fill", "empty", "drain", "flush", "purge", "prune", "clean", "sanitize",
+            "compose", "decompose", "assemble", "disassemble", "construct", "deconstruct",
         ];
 
         const startsWithVerbHandler = (name) => verbPrefixes.some((verb) => name.startsWith(verb));
@@ -3146,8 +3192,10 @@ const multilineIfConditions = {
             if (isCorrectionNeeded) {
                 context.report({
                     fix: (fixer) => {
-                        const indent = " ".repeat(node.loc.start.column + 4);
-                        const parenIndent = " ".repeat(node.loc.start.column);
+                        // Get the indentation of the if statement line
+                        const lineText = sourceCode.lines[node.loc.start.line - 1];
+                        const parenIndent = lineText.match(/^\s*/)[0];
+                        const indent = parenIndent + "    ";
 
                         const buildMultilineHandler = (n) => {
                             if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
@@ -3321,6 +3369,251 @@ const multilineIfConditions = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Ternary Condition Multiline
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   When a ternary condition has multiple operands (>3), format
+ *   each operand on its own line for readability.
+ *
+ * ✓ Good:
+ *   const x = a && b && c ? "yes" : "no";
+ *
+ *   const x =
+ *       variant === "ghost"
+ *       || variant === "ghost-danger"
+ *       || variant === "muted"
+ *       || variant === "primary"
+ *           ? "value1"
+ *           : "value2";
+ *
+ * ✗ Bad:
+ *   const x = variant === "ghost" || variant === "ghost-danger" || variant === "muted" || variant === "primary" ? "value1" : "value2";
+ */
+const ternaryConditionMultiline = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const options = context.options[0] || {};
+        const maxOperands = options.maxOperands ?? 3;
+
+        // Check if node is wrapped in parentheses
+        const isParenthesizedHandler = (node) => {
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            const tokenAfter = sourceCode.getTokenAfter(node);
+
+            if (!tokenBefore || !tokenAfter) return false;
+
+            return tokenBefore.value === "(" && tokenAfter.value === ")";
+        };
+
+        // Get source text including any surrounding parentheses
+        const getSourceTextWithGroupsHandler = (node) => {
+            let start = node.range[0];
+            let end = node.range[1];
+            let left = sourceCode.getTokenBefore(node);
+            let right = sourceCode.getTokenAfter(node);
+
+            while (left && left.value === "(" && right && right.value === ")") {
+                start = left.range[0];
+                end = right.range[1];
+                left = sourceCode.getTokenBefore(left);
+                right = sourceCode.getTokenAfter(right);
+            }
+
+            return sourceCode.text.slice(start, end);
+        };
+
+        // Collect all operands from a logical expression
+        const collectOperandsHandler = (node) => {
+            const operands = [];
+
+            const collectHelperHandler = (n) => {
+                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                    collectHelperHandler(n.left);
+                    collectHelperHandler(n.right);
+                } else {
+                    operands.push(n);
+                }
+            };
+
+            collectHelperHandler(node);
+
+            return operands;
+        };
+
+        // Check if a BinaryExpression is split across lines
+        const isBinaryExpressionSplitHandler = (n) => {
+            if (n.type !== "BinaryExpression") return false;
+
+            const { left, right } = n;
+
+            if (left.loc.end.line !== right.loc.start.line) return true;
+            if (isBinaryExpressionSplitHandler(left)) return true;
+            if (isBinaryExpressionSplitHandler(right)) return true;
+
+            return false;
+        };
+
+        // Collapse a BinaryExpression to single line
+        const buildBinaryExpressionSingleLineHandler = (n) => {
+            if (n.type === "BinaryExpression") {
+                const leftText = buildBinaryExpressionSingleLineHandler(n.left);
+                const rightText = buildBinaryExpressionSingleLineHandler(n.right);
+
+                return `${leftText} ${n.operator} ${rightText}`;
+            }
+
+            return sourceCode.getText(n);
+        };
+
+        // Helper to check if any operator is at end of line (wrong position)
+        const hasOperatorAtEndOfLineHandler = (n) => {
+            if (n.type !== "LogicalExpression") return false;
+
+            const operatorToken = sourceCode.getTokenAfter(
+                n.left,
+                (t) => t.value === "||" || t.value === "&&",
+            );
+
+            if (operatorToken) {
+                const tokenAfterOperator = sourceCode.getTokenAfter(operatorToken);
+
+                if (tokenAfterOperator && operatorToken.loc.end.line < tokenAfterOperator.loc.start.line) {
+                    return true;
+                }
+            }
+
+            if (hasOperatorAtEndOfLineHandler(n.left)) return true;
+            if (hasOperatorAtEndOfLineHandler(n.right)) return true;
+
+            return false;
+        };
+
+        return {
+            ConditionalExpression(node) {
+                const { test } = node;
+
+                // Only handle ternaries with logical expression conditions
+                if (test.type !== "LogicalExpression") return;
+
+                const operands = collectOperandsHandler(test);
+                const testStartLine = test.loc.start.line;
+                const testEndLine = test.loc.end.line;
+                const isMultiLine = testStartLine !== testEndLine;
+
+                // ≤maxOperands operands: keep on single line
+                if (operands.length <= maxOperands) {
+                    const firstOperandStartLine = operands[0].loc.start.line;
+                    const allOperandsStartOnSameLine = operands.every(
+                        (op) => op.loc.start.line === firstOperandStartLine,
+                    );
+
+                    const hasSplitBinaryExpression = operands.some(
+                        (op) => isBinaryExpressionSplitHandler(op),
+                    );
+
+                    if (!allOperandsStartOnSameLine || hasSplitBinaryExpression) {
+                        context.report({
+                            fix: (fixer) => {
+                                const buildSameLineHandler = (n) => {
+                                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                                        const leftText = buildSameLineHandler(n.left);
+                                        const rightText = buildSameLineHandler(n.right);
+
+                                        return `${leftText} ${n.operator} ${rightText}`;
+                                    }
+
+                                    if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
+                                        return buildBinaryExpressionSingleLineHandler(n);
+                                    }
+
+                                    return getSourceTextWithGroupsHandler(n);
+                                };
+
+                                return fixer.replaceText(test, buildSameLineHandler(test));
+                            },
+                            message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
+                            node: test,
+                        });
+                    }
+
+                    return;
+                }
+
+                // More than maxOperands: each on its own line
+                let isCorrectionNeeded = !isMultiLine;
+
+                if (isMultiLine) {
+                    for (let i = 0; i < operands.length - 1; i += 1) {
+                        if (operands[i].loc.end.line === operands[i + 1].loc.start.line) {
+                            isCorrectionNeeded = true;
+                            break;
+                        }
+                    }
+
+                    // Check if any operator is at end of line (should be at beginning)
+                    if (!isCorrectionNeeded && hasOperatorAtEndOfLineHandler(test)) {
+                        isCorrectionNeeded = true;
+                    }
+                }
+
+                if (isCorrectionNeeded) {
+                    context.report({
+                        fix: (fixer) => {
+                            // Get the indentation based on where the ternary starts
+                            const lineText = sourceCode.lines[node.loc.start.line - 1];
+                            const baseIndent = lineText.match(/^\s*/)[0];
+                            const conditionIndent = baseIndent + "    ";
+                            const branchIndent = baseIndent + "        ";
+
+                            const buildMultilineHandler = (n) => {
+                                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                                    const leftText = buildMultilineHandler(n.left);
+                                    const rightText = buildMultilineHandler(n.right);
+
+                                    return `${leftText}\n${conditionIndent}${n.operator} ${rightText}`;
+                                }
+
+                                return getSourceTextWithGroupsHandler(n);
+                            };
+
+                            const consequentText = sourceCode.getText(node.consequent);
+                            const alternateText = sourceCode.getText(node.alternate);
+
+                            const newText = `\n${conditionIndent}${buildMultilineHandler(test)}\n${branchIndent}? ${consequentText}\n${branchIndent}: ${alternateText}`;
+
+                            return fixer.replaceText(node, newText);
+                        },
+                        message: `Ternary conditions with more than ${maxOperands} operands should be multiline, with each operand on its own line`,
+                        node: test,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce multiline formatting for ternary expressions with complex conditions" },
+        fixable: "code",
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    maxOperands: {
+                        default: 3,
+                        description: "Maximum operands to keep on single line (default: 3)",
+                        minimum: 1,
+                        type: "integer",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "layout",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: Absolute Imports Only
@@ -4758,6 +5051,57 @@ const indexExportStyle = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Index Exports Only
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Index files (index.ts, index.tsx, index.js, index.jsx) should
+ *   only contain imports and exports, not type or interface definitions.
+ *   Types should be moved to a separate file (e.g., types.ts).
+ *
+ * ✓ Good:
+ *   // index.ts
+ *   export { Button } from "./Button";
+ *   export type { ButtonProps } from "./types";
+ *
+ * ✗ Bad:
+ *   // index.ts
+ *   export type ButtonVariant = "primary" | "secondary";
+ *   export interface ButtonProps { ... }
+ */
+const indexExportsOnly = {
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+        const isIndexFile = /\/index\.(js|jsx|ts|tsx)$/.test(normalizedFilename)
+            || /^index\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
+
+        if (!isIndexFile) return {};
+
+        return {
+            TSInterfaceDeclaration(node) {
+                context.report({
+                    message: "Interface definitions should not be in index files. Move to a types file.",
+                    node,
+                });
+            },
+            TSTypeAliasDeclaration(node) {
+                context.report({
+                    message: "Type definitions should not be in index files. Move to a types file.",
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Index files should only contain imports and exports, not type definitions" },
+        schema: [],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: JSX Children On New Line
@@ -6319,7 +6663,19 @@ const classNameMultiline = {
                 if (current.type === "JSXAttribute"
                     || current.type === "VariableDeclarator"
                     || current.type === "Property") {
-                    return getLineIndent(current);
+                    const lineIndent = getLineIndent(current);
+                    const lineText = sourceCode.lines[current.loc.start.line - 1];
+
+                    // Check if there's content before the node on this line
+                    const contentBefore = lineText.slice(0, current.loc.start.column).trim();
+
+                    if (contentBefore) {
+                        // Attribute is inline (e.g., <Component className=...>)
+                        // Use column position as indent for proper alignment
+                        return " ".repeat(current.loc.start.column);
+                    }
+
+                    return lineIndent;
                 }
 
                 current = current.parent;
@@ -11992,6 +12348,31 @@ const functionObjectDestructure = {
                     const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
                     context.report({
+                        fix: (fixer) => {
+                            const fixes = [];
+
+                            // Get the first statement in the block body to insert before it
+                            const firstStatement = body.body[0];
+
+                            if (firstStatement) {
+                                // Get indentation from the first statement
+                                const firstStatementLine = sourceCode.lines[firstStatement.loc.start.line - 1];
+                                const indent = firstStatementLine.match(/^\s*/)[0];
+
+                                // Create the destructuring statement
+                                const destructureStatement = `const { ${accessedProps.join(", ")} } = ${paramName};\n${indent}`;
+
+                                // Insert at the beginning of the first statement
+                                fixes.push(fixer.insertTextBefore(firstStatement, destructureStatement));
+                            }
+
+                            // Replace all param.prop accesses with just prop
+                            accesses.forEach((access) => {
+                                fixes.push(fixer.replaceText(access.node, access.property));
+                            });
+
+                            return fixes;
+                        },
                         message: `Parameter "${paramName}" is accessed via dot notation. Destructure it at the top of the function body: "const { ${accessedProps.join(", ")} } = ${paramName};"`,
                         node: accesses[0].node,
                     });
@@ -12017,6 +12398,31 @@ const functionObjectDestructure = {
                             const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
                             context.report({
+                                fix: (fixer) => {
+                                    const fixes = [];
+
+                                    // Get the first statement in the block body to insert before it
+                                    const firstStatement = body.body[0];
+
+                                    if (firstStatement) {
+                                        // Get indentation from the first statement
+                                        const firstStatementLine = sourceCode.lines[firstStatement.loc.start.line - 1];
+                                        const indent = firstStatementLine.match(/^\s*/)[0];
+
+                                        // Create the destructuring statement
+                                        const destructureStatement = `const { ${accessedProps.join(", ")} } = ${propName};\n\n${indent}`;
+
+                                        // Insert at the beginning of the first statement
+                                        fixes.push(fixer.insertTextBefore(firstStatement, destructureStatement));
+                                    }
+
+                                    // Replace all prop.subprop accesses with just subprop
+                                    accesses.forEach((access) => {
+                                        fixes.push(fixer.replaceText(access.node, access.property));
+                                    });
+
+                                    return fixes;
+                                },
                                 message: `Prop "${propName}" is accessed via dot notation. Destructure it at the top of the component: "const { ${accessedProps.join(", ")} } = ${propName};"`,
                                 node: accesses[0].node,
                             });
@@ -12115,6 +12521,44 @@ const componentPropsDestructure = {
             return false;
         };
 
+        // Find all property accesses on a parameter in the function body
+        const findPropAccessesHandler = (body, paramName) => {
+            const accesses = [];
+
+            const visitNode = (n) => {
+                if (!n || typeof n !== "object") return;
+
+                // Check for member expression like props.name
+                if (n.type === "MemberExpression" && !n.computed) {
+                    if (n.object.type === "Identifier" && n.object.name === paramName) {
+                        const propName = n.property.name;
+
+                        accesses.push({
+                            node: n,
+                            property: propName,
+                        });
+                    }
+                }
+
+                // Recurse into child nodes
+                for (const key of Object.keys(n)) {
+                    if (key === "parent") continue;
+
+                    const child = n[key];
+
+                    if (Array.isArray(child)) {
+                        child.forEach(visitNode);
+                    } else if (child && typeof child === "object" && child.type) {
+                        visitNode(child);
+                    }
+                }
+            };
+
+            visitNode(body);
+
+            return accesses;
+        };
+
         const checkComponentPropsHandler = (node) => {
             if (!isReactComponentHandler(node)) return;
 
@@ -12127,12 +12571,53 @@ const componentPropsDestructure = {
             const firstParam = params[0];
 
             if (firstParam.type === "Identifier") {
-                context.report({
-                    message: `Component props should be destructured. Use "({ ...props })" instead of "${firstParam.name}"`,
-                    node: firstParam,
-                });
-            }
-        };
+                const paramName = firstParam.name;
+                const accesses = findPropAccessesHandler(node.body, paramName);
+                const accessedProps = [...new Set(accesses.map((a) => a.property))];
+
+                // Check if param is used directly (not just via dot notation)
+                const allRefs = [];
+                const countRefs = (n) => {
+                    if (!n || typeof n !== "object") return;
+
+                    if (n.type === "Identifier" && n.name === paramName) allRefs.push(n);
+
+                    for (const key of Object.keys(n)) {
+                        if (key === "parent") continue;
+
+                        const child = n[key];
+
+                        if (Array.isArray(child)) child.forEach(countRefs);
+                        else if (child && typeof child === "object" && child.type) countRefs(child);
+                    }
+                };
+
+                countRefs(node.body);
+
+                // Can only auto-fix if all references are covered by dot notation accesses
+                const canAutoFix = accessedProps.length > 0 && allRefs.length === accesses.length;
+
+                context.report({
+                    fix: canAutoFix
+                        ? (fixer) => {
+                            const fixes = [];
+
+                            // Replace param with destructured pattern
+                            fixes.push(fixer.replaceText(firstParam, `{ ${accessedProps.join(", ")} }`));
+
+                            // Replace all props.x with just x
+                            accesses.forEach((access) => {
+                                fixes.push(fixer.replaceText(access.node, access.property));
+                            });
+
+                            return fixes;
+                        }
+                        : undefined,
+                    message: `Component props should be destructured. Use "({ ...props })" instead of "${firstParam.name}"`,
+                    node: firstParam,
+                });
+            }
+        };
 
         return {
             ArrowFunctionExpression: checkComponentPropsHandler,
@@ -12142,6 +12627,7 @@ const componentPropsDestructure = {
     },
     meta: {
         docs: { description: "Enforce that React component props must be destructured in the function parameter" },
+        fixable: "code",
         schema: [],
         type: "suggestion",
     },
@@ -12592,6 +13078,146 @@ const componentPropsInlineType = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: No Inline Type Definitions
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Function parameters with inline union types should be extracted
+ *   to a separate type file. This rule reports union types with
+ *   more than a threshold number of members or exceeding a length limit.
+ *
+ * ✓ Good:
+ *   // In types.ts:
+ *   export type ButtonVariant = "primary" | "muted" | "danger";
+ *
+ *   // In Button.tsx:
+ *   import { ButtonVariant } from "./types";
+ *   export const Button = ({ variant }: { variant?: ButtonVariant }) => ...
+ *
+ * ✗ Bad:
+ *   export const Button = ({ variant }: { variant?: "primary" | "muted" | "danger" }) => ...
+ */
+const noInlineTypeDefinitions = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const options = context.options[0] || {};
+        const maxUnionMembers = options.maxUnionMembers ?? 2;
+        const maxLength = options.maxLength ?? 50;
+
+        // Count union type members
+        const countUnionMembersHandler = (node) => {
+            if (node.type !== "TSUnionType") return 1;
+
+            let count = 0;
+
+            for (const type of node.types) {
+                count += countUnionMembersHandler(type);
+            }
+
+            return count;
+        };
+
+        // Check if a type annotation contains a complex inline union
+        const checkTypeAnnotationHandler = (typeNode, paramName) => {
+            if (!typeNode) return;
+
+            // Handle union types directly
+            if (typeNode.type === "TSUnionType") {
+                const memberCount = countUnionMembersHandler(typeNode);
+                const typeText = sourceCode.getText(typeNode);
+
+                if (memberCount > maxUnionMembers || typeText.length > maxLength) {
+                    context.report({
+                        message: `Inline union type with ${memberCount} members is too complex. Extract to a named type in a types file.`,
+                        node: typeNode,
+                    });
+                }
+
+                return;
+            }
+
+            // Handle object types with union properties
+            if (typeNode.type === "TSTypeLiteral") {
+                for (const member of typeNode.members) {
+                    if (member.type === "TSPropertySignature" && member.typeAnnotation) {
+                        const propType = member.typeAnnotation.typeAnnotation;
+                        const propName = member.key && member.key.name ? member.key.name : "unknown";
+
+                        if (propType && propType.type === "TSUnionType") {
+                            const memberCount = countUnionMembersHandler(propType);
+                            const typeText = sourceCode.getText(propType);
+
+                            if (memberCount > maxUnionMembers || typeText.length > maxLength) {
+                                context.report({
+                                    message: `Property "${propName}" has inline union type with ${memberCount} members. Extract to a named type in a types file.`,
+                                    node: propType,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        return {
+            // Check function parameters
+            ArrowFunctionExpression(node) {
+                for (const param of node.params) {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        const paramName = param.type === "Identifier" ? param.name : "param";
+
+                        checkTypeAnnotationHandler(param.typeAnnotation.typeAnnotation, paramName);
+                    }
+                }
+            },
+            FunctionDeclaration(node) {
+                for (const param of node.params) {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        const paramName = param.type === "Identifier" ? param.name : "param";
+
+                        checkTypeAnnotationHandler(param.typeAnnotation.typeAnnotation, paramName);
+                    }
+                }
+            },
+            FunctionExpression(node) {
+                for (const param of node.params) {
+                    if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                        const paramName = param.type === "Identifier" ? param.name : "param";
+
+                        checkTypeAnnotationHandler(param.typeAnnotation.typeAnnotation, paramName);
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce extracting inline union types to named types in type files" },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    maxLength: {
+                        default: 50,
+                        description: "Maximum character length for inline union types (default: 50)",
+                        minimum: 1,
+                        type: "integer",
+                    },
+                    maxUnionMembers: {
+                        default: 2,
+                        description: "Maximum union members to keep inline (default: 2)",
+                        minimum: 1,
+                        type: "integer",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+};
+
 /*
  * type-format
  *
@@ -13945,25 +14571,162 @@ const reactCodeOrder = {
                     || s.type === "ExpressionStatement"
                     || s.type === "ReturnStatement";
 
+            // Get declared variable names from a statement
+            const getDeclaredNamesHandler = (stmt) => {
+                const names = new Set();
+
+                if (stmt.type === "VariableDeclaration") {
+                    for (const decl of stmt.declarations) {
+                        if (decl.id.type === "Identifier") {
+                            names.add(decl.id.name);
+                        } else if (decl.id.type === "ObjectPattern") {
+                            for (const prop of decl.id.properties) {
+                                if (prop.type === "Property" && prop.value.type === "Identifier") {
+                                    names.add(prop.value.name);
+                                } else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+                                    names.add(prop.argument.name);
+                                }
+                            }
+                        } else if (decl.id.type === "ArrayPattern") {
+                            for (const element of decl.id.elements) {
+                                if (element && element.type === "Identifier") {
+                                    names.add(element.name);
+                                }
+                            }
+                        }
+                    }
+                } else if (stmt.type === "FunctionDeclaration" && stmt.id) {
+                    names.add(stmt.id.name);
+                }
+
+                return names;
+            };
+
+            // Get referenced variable names from a node (recursively)
+            const getReferencedNamesHandler = (node, refs = new Set()) => {
+                if (!node) return refs;
+
+                if (node.type === "Identifier") {
+                    refs.add(node.name);
+                } else if (node.type === "MemberExpression") {
+                    getReferencedNamesHandler(node.object, refs);
+                } else if (node.type === "CallExpression") {
+                    getReferencedNamesHandler(node.callee, refs);
+                    node.arguments.forEach((arg) => getReferencedNamesHandler(arg, refs));
+                } else if (node.type === "BinaryExpression" || node.type === "LogicalExpression") {
+                    getReferencedNamesHandler(node.left, refs);
+                    getReferencedNamesHandler(node.right, refs);
+                } else if (node.type === "ConditionalExpression") {
+                    getReferencedNamesHandler(node.test, refs);
+                    getReferencedNamesHandler(node.consequent, refs);
+                    getReferencedNamesHandler(node.alternate, refs);
+                } else if (node.type === "UnaryExpression") {
+                    getReferencedNamesHandler(node.argument, refs);
+                } else if (node.type === "ArrayExpression") {
+                    node.elements.forEach((el) => getReferencedNamesHandler(el, refs));
+                } else if (node.type === "ObjectExpression") {
+                    node.properties.forEach((prop) => {
+                        if (prop.type === "Property") {
+                            getReferencedNamesHandler(prop.value, refs);
+                        }
+                    });
+                } else if (node.type === "TemplateLiteral") {
+                    node.expressions.forEach((expr) => getReferencedNamesHandler(expr, refs));
+                } else if (node.type === "ChainExpression") {
+                    getReferencedNamesHandler(node.expression, refs);
+                } else if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression") {
+                    getReferencedNamesHandler(node.expression, refs);
+                }
+
+                return refs;
+            };
+
+            // Get dependencies for a statement (variables it uses in initialization)
+            const getStatementDependenciesHandler = (stmt) => {
+                const deps = new Set();
+
+                if (stmt.type === "VariableDeclaration") {
+                    for (const decl of stmt.declarations) {
+                        if (decl.init) {
+                            getReferencedNamesHandler(decl.init, deps);
+                        }
+                    }
+                }
+
+                return deps;
+            };
+
             // Filter to only categorizable statements for order checking
             const categorizableStatements = statements.filter(isCategorizableStatement);
 
             if (categorizableStatements.length < 2) return;
 
-            // Check order violations using only categorizable statements
+            // Build dependency information for all statements
+            const stmtInfo = new Map();
+            const declaredNames = new Map(); // Map from variable name to statement index
+
+            // First pass: build declaredNames map (so we can look up where each variable is declared)
+            for (let i = 0; i < statements.length; i++) {
+                const stmt = statements[i];
+                const declared = getDeclaredNamesHandler(stmt);
+
+                for (const name of declared) {
+                    declaredNames.set(name, i);
+                }
+            }
+
+            // Second pass: build full statement info including dependencies
+            for (let i = 0; i < statements.length; i++) {
+                const stmt = statements[i];
+                const declared = getDeclaredNamesHandler(stmt);
+                const dependencies = getStatementDependenciesHandler(stmt);
+                const category = isCategorizableStatement(stmt)
+                    ? getStatementCategoryHandler(stmt, propNames)
+                    : ORDER.UNKNOWN;
+
+                stmtInfo.set(i, {
+                    category,
+                    declared,
+                    dependencies,
+                    index: i,
+                    statement: stmt,
+                });
+            }
+
+            // Build dependency graph first
+            const dependsOn = new Map(); // stmtIndex -> Set of stmtIndices it depends on
+
+            for (let i = 0; i < statements.length; i++) {
+                const info = stmtInfo.get(i);
+                const deps = new Set();
+
+                for (const depName of info.dependencies) {
+                    const depIndex = declaredNames.get(depName);
+
+                    if (depIndex !== undefined && depIndex !== i) {
+                        deps.add(depIndex);
+                    }
+                }
+
+                dependsOn.set(i, deps);
+            }
+
+            // Check for violations: category order OR dependency order
             let hasOrderViolation = false;
+            let hasDependencyViolation = false;
             let lastCategory = 0;
             let violatingStatement = null;
             let violatingCategory = null;
             let previousCategory = null;
+            let dependencyViolationStmt = null;
+            let dependencyViolationVar = null;
 
+            // Check category violations
             for (const statement of categorizableStatements) {
                 const category = getStatementCategoryHandler(statement, propNames);
 
-                // Skip unknown statements for order checking
                 if (category === ORDER.UNKNOWN) continue;
 
-                // Check if current category comes before the last one
                 if (category < lastCategory && !hasOrderViolation) {
                     hasOrderViolation = true;
                     violatingStatement = statement;
@@ -13974,114 +14737,407 @@ const reactCodeOrder = {
                 lastCategory = category;
             }
 
-            if (!hasOrderViolation) return;
+            // Check dependency violations (using variable before declaration)
+            for (let i = 0; i < statements.length; i++) {
+                const deps = dependsOn.get(i) || new Set();
 
-            // For auto-fix, process ALL statements and assign sort keys
-            // Non-categorizable statements (if, for, while, etc.) get the category of the NEXT categorizable statement
-            // This keeps them positioned just before whatever comes after them
-            const allStatementsWithSortKeys = [];
+                for (const depIndex of deps) {
+                    if (depIndex > i) {
+                        // This statement uses a variable declared later
+                        hasDependencyViolation = true;
+                        dependencyViolationStmt = statements[i];
 
-            // First pass: assign categories to categorizable statements
-            const categoryMap = new Map();
+                        // Find the variable name
+                        const depInfo = stmtInfo.get(depIndex);
 
-            for (const stmt of statements) {
-                if (isCategorizableStatement(stmt)) {
-                    categoryMap.set(stmt, getStatementCategoryHandler(stmt, propNames));
+                        for (const name of depInfo.declared) {
+                            const currentDeps = stmtInfo.get(i).dependencies;
+
+                            if (currentDeps.has(name)) {
+                                dependencyViolationVar = name;
+
+                                break;
+                            }
+                        }
+
+                        break;
+                    }
                 }
+
+                if (hasDependencyViolation) break;
             }
 
-            // Second pass: assign sort keys to all statements
-            // Non-categorizable statements get the category of the next categorizable statement
-            for (let i = 0; i < statements.length; i++) {
-                const stmt = statements[i];
-                let sortKey;
+            if (!hasOrderViolation && !hasDependencyViolation) return;
 
-                if (isCategorizableStatement(stmt)) {
-                    sortKey = categoryMap.get(stmt);
-                } else {
-                    // Find the next categorizable statement's category
-                    sortKey = ORDER.RETURN; // Default to RETURN if none found
+            // Dependency-aware topological sort
+            // Sort by category, but ensure dependencies come before dependents
+            const sortWithDependenciesHandler = () => {
+                const result = [];
+                const visited = new Set();
+                const visiting = new Set(); // For cycle detection
 
-                    for (let j = i + 1; j < statements.length; j++) {
-                        if (isCategorizableStatement(statements[j])) {
-                            sortKey = categoryMap.get(statements[j]);
+                // DFS-based topological sort
+                const visitHandler = (index) => {
+                    if (visited.has(index)) return;
+                    if (visiting.has(index)) return; // Cycle detected, skip
 
-                            break;
+                    visiting.add(index);
+
+                    // Visit dependencies first
+                    const deps = dependsOn.get(index) || new Set();
+
+                    for (const depIndex of deps) {
+                        visitHandler(depIndex);
+                    }
+
+                    visiting.delete(index);
+                    visited.add(index);
+                    result.push(index);
+                };
+
+                // Group statements by category first, then sort within each group by dependencies
+                const byCategory = new Map();
+
+                for (let i = 0; i < statements.length; i++) {
+                    const info = stmtInfo.get(i);
+                    let effectiveCategory = info.category;
+
+                    // For non-categorizable statements, use the next categorizable statement's category
+                    if (effectiveCategory === ORDER.UNKNOWN) {
+                        for (let j = i + 1; j < statements.length; j++) {
+                            const nextInfo = stmtInfo.get(j);
+
+                            if (nextInfo.category !== ORDER.UNKNOWN) {
+                                effectiveCategory = nextInfo.category;
+
+                                break;
+                            }
+                        }
+
+                        if (effectiveCategory === ORDER.UNKNOWN) {
+                            effectiveCategory = ORDER.RETURN;
+                        }
+                    }
+
+                    // Check if this statement has dependencies from a later category
+                    // If so, it needs to come after those dependencies
+                    const deps = dependsOn.get(i) || new Set();
+                    let maxDepCategory = effectiveCategory;
+
+                    for (const depIndex of deps) {
+                        const depInfo = stmtInfo.get(depIndex);
+                        let depCategory = depInfo.category;
+
+                        if (depCategory === ORDER.UNKNOWN) {
+                            depCategory = ORDER.DERIVED_STATE; // Assume derived for unknown
+                        }
+
+                        if (depCategory > maxDepCategory) {
+                            maxDepCategory = depCategory;
                         }
                     }
+
+                    // If dependencies are from a later category, this statement must come after them
+                    // So we use the max dependency category as the effective category
+                    const sortCategory = Math.max(effectiveCategory, maxDepCategory);
+
+                    if (!byCategory.has(sortCategory)) {
+                        byCategory.set(sortCategory, []);
+                    }
+
+                    byCategory.get(sortCategory).push({
+                        deps,
+                        effectiveCategory,
+                        index: i,
+                        originalCategory: info.category,
+                    });
                 }
 
-                allStatementsWithSortKeys.push({
-                    index: i,
-                    sortKey,
-                    statement: stmt,
-                });
-            }
+                // Sort categories
+                const sortedCategories = [...byCategory.keys()].sort((a, b) => a - b);
+
+                // Build final sorted list
+                const finalResult = [];
+
+                for (const category of sortedCategories) {
+                    const stmtsInCategory = byCategory.get(category);
+
+                    // Sort statements within category by dependencies using topological sort
+                    const categoryVisited = new Set();
+                    const categoryResult = [];
+
+                    const visitCategoryHandler = (item) => {
+                        if (categoryVisited.has(item.index)) return;
+
+                        categoryVisited.add(item.index);
+
+                        // Visit dependencies in same category first
+                        for (const depIndex of item.deps) {
+                            const depItem = stmtsInCategory.find((s) => s.index === depIndex);
+
+                            if (depItem && !categoryVisited.has(depIndex)) {
+                                visitCategoryHandler(depItem);
+                            }
+                        }
+
+                        categoryResult.push(item.index);
+                    };
+
+                    // Sort by original index first to maintain stability
+                    stmtsInCategory.sort((a, b) => a.index - b.index);
+
+                    for (const item of stmtsInCategory) {
+                        visitCategoryHandler(item);
+                    }
 
-            // Sort all statements by sort key (stable sort - maintains relative order within same key)
-            const sortedStatements = [...allStatementsWithSortKeys].sort((a, b) => {
-                if (a.sortKey !== b.sortKey) {
-                    return a.sortKey - b.sortKey;
+                    finalResult.push(...categoryResult);
                 }
 
-                // Maintain original order within the same sort key
-                return a.index - b.index;
-            });
+                return finalResult;
+            };
+
+            const sortedIndices = sortWithDependenciesHandler();
 
             // Check if sorting actually changes the order
-            const orderChanged = sortedStatements.some((s, i) => s.index !== i);
+            const orderChanged = sortedIndices.some((idx, i) => idx !== i);
 
             if (!orderChanged) return;
 
             // Build the fix
             const fixHandler = (fixer) => {
-                // Get the base indentation from the first statement
                 const firstStatementLine = sourceCode.lines[statements[0].loc.start.line - 1];
                 const baseIndent = firstStatementLine.match(/^\s*/)[0];
 
-                // Build new body content
                 let newBodyContent = "";
-                let lastSortKey = null;
+                let lastCategory = null;
 
-                for (let i = 0; i < sortedStatements.length; i++) {
-                    const { sortKey, statement } = sortedStatements[i];
+                for (let i = 0; i < sortedIndices.length; i++) {
+                    const stmtIndex = sortedIndices[i];
+                    const info = stmtInfo.get(stmtIndex);
+                    const category = info.category !== ORDER.UNKNOWN ? info.category : null;
 
-                    // Add blank line between different categories (except UNKNOWN)
-                    if (lastSortKey !== null && sortKey !== ORDER.UNKNOWN && lastSortKey !== ORDER.UNKNOWN && sortKey !== lastSortKey) {
+                    // Add blank line between different categories
+                    if (lastCategory !== null && category !== null && category !== lastCategory) {
                         newBodyContent += "\n";
                     }
 
-                    // Get the statement text with proper indentation
-                    const stmtText = sourceCode.getText(statement);
+                    const stmtText = sourceCode.getText(info.statement);
 
                     newBodyContent += baseIndent + stmtText.trim() + "\n";
 
-                    lastSortKey = sortKey;
+                    if (category !== null) {
+                        lastCategory = category;
+                    }
                 }
 
-                // Find the range to replace (all statements)
                 const firstStmt = statements[0];
                 const lastStmt = statements[statements.length - 1];
 
                 return fixer.replaceTextRange([firstStmt.range[0], lastStmt.range[1]], newBodyContent.trimEnd());
             };
 
-            context.report({
-                data: {
-                    current: ORDER_NAMES[violatingCategory],
-                    previous: ORDER_NAMES[previousCategory],
-                    type: isHook ? "hook" : "component",
-                },
-                fix: fixHandler,
-                message: "\"{{current}}\" should come before \"{{previous}}\" in {{type}}. Order: refs → state → redux → router → context → custom hooks → derived → useMemo → useCallback → handlers → useEffect → return",
-                node: violatingStatement,
-            });
+            // Report the appropriate violation
+            if (hasDependencyViolation && dependencyViolationStmt) {
+                context.report({
+                    data: {
+                        type: isHook ? "hook" : "component",
+                        varName: dependencyViolationVar || "variable",
+                    },
+                    fix: fixHandler,
+                    message: "\"{{varName}}\" is used before it is declared. Reorder statements so dependencies are declared first in {{type}}",
+                    node: dependencyViolationStmt,
+                });
+            } else if (hasOrderViolation && violatingStatement) {
+                context.report({
+                    data: {
+                        current: ORDER_NAMES[violatingCategory],
+                        previous: ORDER_NAMES[previousCategory],
+                        type: isHook ? "hook" : "component",
+                    },
+                    fix: fixHandler,
+                    message: "\"{{current}}\" should come before \"{{previous}}\" in {{type}}. Order: refs → state → redux → router → context → custom hooks → derived → useMemo → useCallback → handlers → useEffect → return",
+                    node: violatingStatement,
+                });
+            }
+        };
+
+        // Check for module-level constants that should be inside the component
+        const checkModuleLevelConstantsHandler = (node, isHook) => {
+            const sourceCode = context.sourceCode || context.getSourceCode();
+
+            // Get the program (root) node to find module-level declarations
+            let programNode = node;
+
+            while (programNode.parent) {
+                programNode = programNode.parent;
+            }
+
+            if (programNode.type !== "Program") return;
+
+            // Get the component body for insertion
+            const componentBody = node.body;
+
+            if (componentBody.type !== "BlockStatement") return;
+
+            // Get component/hook name
+            const componentName = getFunctionNameHandler(node);
+
+            // Find module-level variable declarations with simple literal values
+            for (const statement of programNode.body) {
+                if (statement.type !== "VariableDeclaration") continue;
+
+                for (const decl of statement.declarations) {
+                    if (!decl.init || !decl.id || decl.id.type !== "Identifier") continue;
+
+                    const varName = decl.id.name;
+
+                    // Only check simple literals (numbers, strings, booleans)
+                    const isSimpleLiteral = decl.init.type === "Literal"
+                        && (typeof decl.init.value === "number"
+                            || typeof decl.init.value === "string"
+                            || typeof decl.init.value === "boolean");
+
+                    if (!isSimpleLiteral) continue;
+
+                    // Skip if it looks like a config constant (SCREAMING_CASE is typically intentional module-level)
+                    if (/^[A-Z][A-Z0-9_]*$/.test(varName)) continue;
+
+                    // Check if this variable is used inside the current component/hook
+                    const componentText = sourceCode.getText(node);
+
+                    // Simple check: see if the variable name appears in the component
+                    // Use word boundary to avoid false positives
+                    const regex = new RegExp(`\\b${varName}\\b`);
+
+                    if (regex.test(componentText)) {
+                        // Build the fix
+                        const fixHandler = (fixer) => {
+                            const fixes = [];
+
+                            // Get the declaration text
+                            const declText = sourceCode.getText(decl);
+                            const kind = statement.kind; // const, let, var
+
+                            // Remove from module level
+                            if (statement.declarations.length === 1) {
+                                // Remove the entire statement including newline
+                                const nextToken = sourceCode.getTokenAfter(statement);
+                                const endPos = nextToken ? statement.range[1] : statement.range[1];
+
+                                // Include trailing newline if present
+                                const textAfter = sourceCode.text.slice(statement.range[1], statement.range[1] + 2);
+                                const removeEnd = textAfter.startsWith("\n") ? statement.range[1] + 1
+                                    : textAfter.startsWith("\r\n") ? statement.range[1] + 2
+                                        : statement.range[1];
+
+                                fixes.push(fixer.removeRange([statement.range[0], removeEnd]));
+                            } else {
+                                // Remove just this declarator (and comma)
+                                const declIndex = statement.declarations.indexOf(decl);
+                                const isLast = declIndex === statement.declarations.length - 1;
+
+                                if (isLast) {
+                                    // Remove comma before and the declarator
+                                    const prevDecl = statement.declarations[declIndex - 1];
+
+                                    fixes.push(fixer.removeRange([prevDecl.range[1], decl.range[1]]));
+                                } else {
+                                    // Remove declarator and comma after
+                                    const nextDecl = statement.declarations[declIndex + 1];
+
+                                    fixes.push(fixer.removeRange([decl.range[0], nextDecl.range[0]]));
+                                }
+                            }
+
+                            // Find the right position to insert inside the component
+                            // Insert after all hooks but before handlers
+                            const bodyStatements = componentBody.body;
+
+                            // Get the base indentation inside the component
+                            let insertIndent = "    "; // Default
+
+                            if (bodyStatements.length > 0) {
+                                const firstStmtLine = sourceCode.lines[bodyStatements[0].loc.start.line - 1];
+
+                                insertIndent = firstStmtLine.match(/^\s*/)[0];
+                            }
+
+                            // Find insertion point: after last hook/derived state, before handlers
+                            let insertIndex = 0;
+
+                            for (let i = 0; i < bodyStatements.length; i++) {
+                                const stmt = bodyStatements[i];
+
+                                if (stmt.type === "VariableDeclaration") {
+                                    const stmtDecl = stmt.declarations[0];
+
+                                    if (stmtDecl && stmtDecl.init) {
+                                        // Check if it's a hook call
+                                        if (stmtDecl.init.type === "CallExpression") {
+                                            const callee = stmtDecl.init.callee;
+                                            const hookName = callee.type === "Identifier" ? callee.name
+                                                : callee.type === "MemberExpression" && callee.property.type === "Identifier"
+                                                    ? callee.property.name
+                                                    : "";
+
+                                            if (/^use[A-Z]/.test(hookName)) {
+                                                insertIndex = i + 1;
+
+                                                continue;
+                                            }
+                                        }
+
+                                        // Check if it's a function (handler)
+                                        if (stmtDecl.init.type === "ArrowFunctionExpression"
+                                            || stmtDecl.init.type === "FunctionExpression") {
+                                            break;
+                                        }
+
+                                        // It's derived state, insert after it
+                                        insertIndex = i + 1;
+                                    }
+                                } else if (stmt.type === "FunctionDeclaration") {
+                                    // Handler function, stop here
+                                    break;
+                                }
+                            }
+
+                            // Insert the constant
+                            const newLine = `${insertIndent}${kind} ${declText};\n\n`;
+
+                            if (insertIndex === 0 && bodyStatements.length > 0) {
+                                // Insert at the beginning
+                                fixes.push(fixer.insertTextBefore(bodyStatements[0], newLine));
+                            } else if (insertIndex < bodyStatements.length) {
+                                // Insert before the target statement
+                                fixes.push(fixer.insertTextBefore(bodyStatements[insertIndex], newLine));
+                            } else if (bodyStatements.length > 0) {
+                                // Insert at the end
+                                fixes.push(fixer.insertTextAfter(bodyStatements[bodyStatements.length - 1], "\n\n" + insertIndent + kind + " " + declText + ";"));
+                            }
+
+                            return fixes;
+                        };
+
+                        context.report({
+                            data: {
+                                name: varName,
+                                type: isHook ? "hook" : "component",
+                            },
+                            fix: fixHandler,
+                            message: "Constant \"{{name}}\" should be declared inside the {{type}} as derived state, not at module level",
+                            node: decl.id,
+                        });
+                    }
+                }
+            }
         };
 
         const checkFunctionHandler = (node) => {
             // Check if it's a React component
             if (isReactComponentHandler(node)) {
                 checkCodeOrderHandler(node, false);
+                checkModuleLevelConstantsHandler(node, false);
 
                 return;
             }
@@ -14089,6 +15145,7 @@ const reactCodeOrder = {
             // Check if it's a custom hook
             if (isCustomHookHandler(node)) {
                 checkCodeOrderHandler(node, true);
+                checkModuleLevelConstantsHandler(node, true);
             }
         };
 
@@ -14665,6 +15722,7 @@ export default {
         "if-statement-format": ifStatementFormat,
         "multiline-if-conditions": multilineIfConditions,
         "no-empty-lines-in-switch-cases": noEmptyLinesInSwitchCases,
+        "ternary-condition-multiline": ternaryConditionMultiline,
 
         // Function rules
         "function-call-spacing": functionCallSpacing,
@@ -14684,6 +15742,7 @@ export default {
         "import-format": importFormat,
         "import-source-spacing": importSourceSpacing,
         "index-export-style": indexExportStyle,
+        "index-exports-only": indexExportsOnly,
         "module-index-exports": moduleIndexExports,
 
         // JSX rules
@@ -14716,6 +15775,7 @@ export default {
         // TypeScript rules
         "enum-format": enumFormat,
         "interface-format": interfaceFormat,
+        "no-inline-type-definitions": noInlineTypeDefinitions,
         "type-annotation-spacing": typeAnnotationSpacing,
         "type-format": typeFormat,
         "typescript-definition-location": typescriptDefinitionLocation,